In my ongoing endeavor to learn Elixir, Programming Erlang was the second book I read; the first being Programming Elixir >= 1.6.

This may seem like an interesting trajectory for an Elixir noob, but in retrospect I think it was an excellent decision, given my background and learning style.

Here’s how it is: I’m a Java programmer by trade with almost 20 years under my belt, and along the way I’ve dabbled in other JVM languages like Groovy, Scala, and Clojure, with the latter capturing my attention the most.

So, my background is working in the language “closest” to its virtual machine, and branching out from there.

Also, my learning style favors a linear, comprehensive, foundational approach: I seek out materials and approaches that imply “okay, if you just stick with this path, you’ll have a solid foundation by the end.”

I think this is why a gravitate towards books instead of blogs, tutorials, etc.

At any rate, I worked through half of Programming Elixir >= 1.6 and felt a bit lost; things were going too fast for me.

That’s when I thought, “Okay, let’s slow down. What can I read that appears to be foundational and comprehensive?”

I landed on Programming Erlang because things don’t get any more foundational than Erlang and I knew I was in for a treat, having previously read Joe Armstrong’s doctoral thesis; I’m delighted to say it was everything I was hoping for.

It’s clear that Joe had a real gift for explaining things; the prose is patient yet concise and digs into details without belaboring the point.

The progression from sequential programming to concurrency feels steady and natural; by the time we reached concurrency I was ready to see what it was all about. (This is in stark contrast to the premise of tackling concurrency in Java, which is scary and better left to the experts.)

The latter third of the book provides a lot of valuable exposure to other details of the BEAM and its ecosystem, e.g., distributed programming, tracing, logging, monitoring, etc.

In all, this was exactly the sort of foundation I was seeking and I feel that my subsequent and ongoing travels in Elixirland have benefitted tremendously from my side-trip into Erlang.

Fantastic review, thanks for posting Ted!!

I had originally planned to read this book after all my Elixir books, but your review has made me want to read it sooner.

Only thing is I miss Joe, and reading his book will probably make me feel quite emotional

I think I might read it after Programming Phoenix, since I’ll have gotten most of the beginners books out of the way and the rest are mainly about OTP, systems architecture or more advanced topics.

Did you read the book start to finish? Is that how you recommend it is read?

And thank you for the nudge in posting the review!

My trick was to play a cycle of “Hello Robert / Mike / Joe!” in my mind at every ah-ha moment, of which there were many.

That might work out really well; the last handful of chapters are about OTP and systems, starting with building up a hand-rolled version of GenServer.

That’ll probably be a really nice segue into your remaining reading list.

Yes, I usually read books cover-to-cover, even on the occasion when they suggest jumping around because I’m usually seeking that foundation and exposure.

I recommend reading this one start-to-finish: there’s no overarching project being built throughout the book, but the chapters do build on each other.

And even in the introductory “this is a list, this a tuple, …” material, there were plenty of nuggets that had me thinking “okay, so that’s why Elixir does what it does”, although YMMV because I only had a very rudimentary familiarity with Elixir at the time.