Developing with Elixir/OTP Course Review

Ruby was the first programming language I truly fell in love with. Yes, I had used several others before (and have since), but Ruby was and still is something dear to me.

I can appreciate the usefulness of Python, the simplicity of Go, and the mind-expanding nature of Haskell. Yet, anything that isn’t Ruby felt like a usability downgrade. It’s all highly subjective, ça va sans dire, but Ruby was always my favorite.

It’s not every day that a language comes along and genuinely excites me to the point of putting Ruby aside (within the scope of what it’s great at doing).

I <3 Elixir

That language is Elixir. I’ve been using it on and off for a few years now. I first talked about it back in 2016 and even managed to convince my team at IBM to adopt it to an extent. It’s working out well for us so far and I have a hunch we might double down on it soon.

Since I have a little more time, due to being stuck inside, I’ve been on a “study anything in sight related to Elixir and Phoenix” kick lately.

I am a big fan of Mike and Nicole Clark of The Pragmatic Studio and in the past have highly recommended their Ruby and Rails courses. So I decided to start taking their Elixir courses as well. In this post, I’ll give you a fairly detailed review of their largest course on the subject, Developing with Elixir/OTP.

Who is it for?

Developing with Elixir/OTP is aimed at programmers. It’s so well explained that beginners can give it a shot, however, they are not the target audience.

The course assumes you have zero knowledge of Elixir itself but it’s not going to explain basic programming concepts when they are not novel or unique to Elixir.

Experience with Ruby is not required nor assumed, but it’s beneficial. This isn’t so much due to the way the course is presented (though there are a couple of nods to Ruby programmers). Rather, it’s the similarity (on the surface) between the two languages.

How much time do you need to invest?

Developing with Elixir/OTP is a 6.5 hour course divided across 30 modules. There is no way for you to take this course in 6.5 hours and get anything worthwhile from it.

In fact, the secret sauce is that each module has a Notes section dedicated to expanding on the topic, providing tips and tricks, as well as exercises. 

I would estimate that it took me around 20 hours or so to finish, despite being very familiar with the subject matter. Mind you, I do like to experiment quite a bit within IEx to veer off the beaten path.

Estimate 30 hours of your time, an hour per module, if you intend to fully absorb and experiment with the material presented.

Unlike their Rails course, you won’t develop two applications (one while watching the videos and one in the Notes section). In this course, there is only one application that is mostly developed in the videos and then enhanced in the Notes through exercises.

This will save you a lot of time at the small expense of having to pause and resume the video to type along.

Another time-saver is that the code for each module in the course is provided so that you’re never lost. Particularly useful to copy and paste the more tedious parts (e.g., sample data and template code).

What will you build?

The course starts off by developing a simple web server. Think, high-level transformations of requests into responses. It builds it from the ground up and then layers a simple RESTful API for a fictitious wildlife reserve on top.

They start off with the simplest thing, a function that transforms one specific request into one specific response, and then move up all the way to actually serving the API over HTTP.

The goal, as often stated in the course, is not to replace an established and much more robust web server like Cowboy or a framework like Phoenix. At all.

Instead, it serves two pedagogical purposes. First, it teaches you how to use the language to solve a fairly complex problem. Second, it gives you a deeper understanding of how the production-ready tools you are going to adopt actually work within.

This approach is endemic to their teaching method. For example, they’ll develop a simple web server and API from scratch and then show you how similar it is to the equivalent Phoenix version. By the time you hit module 17 on Phoenix, you don’t quite know Phoenix but it should feel oddly familiar. After all, you built a naïve/simplified version of the same controllers, router, templates, etc. from scratch. This is, of course, a deliberate choice.

The same is true when they implement a simple GenServer from scratch and then are able to seamlessly replace it with the real deal (with use GenServer). Yes, you developed the Fisher-Price version of the production-ready tools, but you now understand how they work under the hood. All before Mike and Nicole proceed to teach you how to use the battle-tested ones.

I’m a fan of this didactic approach and I think it will serve most people well.

What will you learn?

It might be surprising to some but this course does not provide the typical tour of data types and data structures available in the language.

Instead, it uses the language to build something from the beginning and, in the process, it quickly exposes you to a variety of concepts, including how to use common data types.

It doesn’t cover them thoroughly, however, so reading the Elixir tutorial on the official site would be very beneficial prior to or after taking this course.

The course starts off with several modules that are heavily focused on pattern matching. This is a good choice because pattern matching is one of the most valuable and pervasive features of Elixir.

As you would expect, there is also quite a bit of emphasis on immutable data structures, the pipe operator, recursion, and the Enum module.

In the process you’ll also learn a lot about IEx, Mix, organizing your code in a logical and idiomatic manner, defining Structs as the safer alternatives to maps, and comprehensions. 

Testing is covered adequately but not extensively in its own module. Not in a TDD manner from the very start of the course like they did in some of their previous courses. This has, again, didactical advantages even if you choose to adopt TDD in your actual work.

In the second half of the course, things get a little more serious courtesy of OTP, delving deeper into working with sockets, the actor model, Task, GenServer, and linking and monitoring processes.

Other points worth making

In more or less random order:

• The course is up to date to Elixir 1.10.x, somewhat rare among Elixir courses. Some of the videos show Mike and Nicole using a previous version (i.e., 1.5), but the Notes use the latest version and the rare differences are noted.  For example, the video shows the old mix new project format which included a config folder. In their hands-on notes for the video, they have a comprehensive “I don’t see a config directory” section to address it. You’re basically never lost or confused due to version discrepancies.
• The overall quality is excellent. It’s a really polished product in terms of audio, video, text, and visuals used to aid in explaining the more conceptual parts.
• They answer the overwhelming majority of your “wait a second” questions and objections. Either later in the video or right in the notes for that particular module. They genuinely anticipate most questions, which is the hallmark of a great course.
• Most modules have a single 5-15 minute video, but some modules include two videos. So the modules are… well, modular.
• Although this course will equip you to start studying Phoenix, it doesn’t really cover the subject. There is a module, as I mentioned, which is just enough to whet your appetite for the framework.
• Erlang interoperability is at least in part addressed in module 20, where sample code from the documentation of gen_tcp is converted from Erlang to Elixir code.
• The course is full of small tips like enabling command history in IEx (with export ERL_AFLAGS="-kernel shell_history enabled"), speeding up unit tests by making them asynchronous (i.e., use ExUnit.Case, async: true), using flush() to clear a process’ mailbox, etc.

Is it worth the price?

At $89, Developing with Elixir/OTP is not your average Udemy course that’s routinely discounted to $12. That’s because it’s not your average course.

If I had to rate it, I’d give it a 4.5 out of 5. I highly recommend it to working programmers who are interested in picking up Elixir quickly.

I would argue that it’s a great, current resource that is well worth the price of admission if you favor learning from videos.

Originally published on Programming Zen.