2022 New Language Resolutions

2022 New Language Resolutions
Photo by Ray Hennessy / Unsplash

One of the most valuable things a programmer can do with their time is to continue to learn new things.

Not only does this help to maintain the mental flexibility that is critical for tackling problems in ever-changing environments, but is simply makes life more fun.

Half a lifetime ago, I would pick up programming languages at the pace of one every few months. But ever since learning Ruby in the mid 2000s, I just haven't felt the need to anymore. It's almost as if every language I've tried to pick up since has been a disappointment in one way or another: Ruby was the hammer to all of life's nails.

Ruby is certainly not without it's faults. Without turning this into a litany of accusations against the language that I terribly appreciate, I do miss my earlier days of learning languages just for the sake of learning languages.

So that what I'm going to do this year: My New Year's Resolution for 2022 is to master four programming languages that I've at most written a "Hello World" in before this year.

Definition of Mastery

When I say master, I don't mean achieving an equivalent level of fluency to a language in which I have nearly two decades of experience using. That would be ridiculous.

Instead I mean intrinsically understanding and applying the fundamentals of what makes that language stand out, both at an intellectual and reflexive level. And the best way to really showcase that would be to write production software in that language.

So that's what I'm going to do by the end of the year: Four different capstone projects written in four different languages. While I'd like to ensure that they're FOSS and available on my github, that may or may not be possible, depending on what I end up working on.

Here's what I chose to explore:


A dynamic, functional language, Elixir leverages the BEAM/OTP run-time environment (also utilized by Erlang) to provide a robust low-latency, vertically and horizontally distributed, fault-tolerant platform upon which to run your code.

I have received multiple recommendations to check out Elixir, along with the Ecto and Phoenix frameworks and after finally looking into it, I have to admit I'm quite excited to start learning this. The biggest weakness I perceive of Rails is it's lack of scalability, which appears to be a complete non-issue with Phoenix.

As far as a specific capstone goes, I will likely utilize Phoenix to write a web-based something or other, basically one of the following:

  • A private internet registry (think ICANN) management system to allow for small groups of users to manage and organize address allocations for private Internets (IETF RFC1918).
  • The management system for one of the handful of SaaS/PaaS startups I'm involved with.


Optimized as a client-development oriented language, Dart is a class-based object-oriented garbage-collected language with a C style syntax that compiles to either native or JavaScript, allowing for a unified client development pathway to be applied to multiple platforms (Web, Mobile, Desktop).

As with Elixir, my interest in Dart is primarily focused on a single framework.


I've never really been that excited for single-page web-applications until now, and while I would like to learn about how Phoenix handles templating and HTML, I would also like to completely avoid that all together and just pass structured data to a much more solidly implemented front-end.

As far as projects are concerned, any web-backend I write with Elixir/Phoenix will likely be accompanied by a front-end written in Dart/Flutter.


The original language that ran on BEAM/OTP, Erlang compiles to effectively equivalent bytecode that Elixir does, and they can call on each other as well, making learning Erlang an excellent choice after learning Elixir and vice versa.

While I could easily fold my Erlang capstone into the same Phoenix based capstone I proposed for learning Elixir, I'd much rather push myself to do something a bit grander with it. No idea what it'll be specifically, but most likely something that plays well to Erlangs strengths, so likely something that can take advantage of low-latency, vertical and horizontal scalability and distribution, along with robust fault-tolerance:

  • Reimplementation of some existing server implementation that doesn't currently scale well.

That's all I'm going to say for now, as I still have plenty of time to figure this out.


A modern systems-level language that is quite possibly the successor to C, Rust is a high performance multi-paradigm language designed for safety, specifically around concurrent memory access. Rust balance of high and low level features makes it very well suited for a lot of different use cases, and it has already seen adoption in the desktop application, CLI application, system application and operating system spaces.

Beyond functioning quite capably on its own, Rust can also be used to implement Erlang Native Implemented Functions (NIFs) thanks to the Rustler Mix package, making it perfectly suitable for writing procedures that will be used in the Erlang OTP.

As with Erlang, I'm not sure exactly what my specific capstone project will be with Rust, though due to the NIF compatibility, I will likely attempt to combine projects for both of these languages.

Honorable Mentions

There are a few other languages that I would absolutely love to pick up this year, but don't want to risk potentially crowding capstone project time by committing to learning them at this time:

  • Go. A statically typed compiled garbage-collected general-purpose language, inspired by C, similar to Rust in some ways and different in others, that's well suited to large concurrent systems.
  • Crystal. A statically typed compiled garbage-collected general-purpose object-oriented language syntactically inspired by Ruby and with concurrency inspirations from Go.