Programming Erlang: Software for a Concurrent World by Joe Armstrong — Summary & Review

“Programming Erlang: Software for a Concurrent World” is the kind of book that doesn’t just teach you a language; it forces you to rethink how you approach programming itself. Joe Armstrong, one of Erlang’s masterminds, lays out why Erlang exists and why it’s still relevant, especially when you’re building software that needs to juggle many things at once without crashing spectacularly.

The book starts by tackling the big problem Erlang was built to solve: concurrency and fault tolerance. In a world where apps often need to handle thousands of simultaneous users or devices, traditional programming languages tend to choke or force you into complex, error-prone patterns. Erlang’s approach is different. It treats processes as lightweight, isolated actors that communicate through message passing. No shared state, no locks, no mysterious race conditions lurking in the shadows.

Armstrong doesn’t assume you’re a functional programming wizard. He patiently walks through Erlang’s syntax and functional style, which can feel like a culture shock for developers used to objects and mutable state. But this isn’t just academic; the functional approach is a foundational piece of Erlang’s reliability puzzle. Once you grasp that, the book dives into the heart of Erlang’s concurrency model. You learn how to spawn thousands—even millions—of tiny processes that run independently but can talk to each other safely.

One of the book’s standout sections is its treatment of fault tolerance. Unlike many programming books that treat errors as something to avoid or hide, Armstrong embraces failure as a first-class citizen. Erlang’s “let it crash” philosophy encourages designing systems that detect failure quickly and recover gracefully. The book explains this mindset with practical examples, showing how to build systems that keep running even when parts go sideways.

Distributed programming gets a fair share of attention too. Erlang was born in the telecom world, where systems span multiple machines and continents. Armstrong explains how Erlang’s built-in support for distributed nodes makes remote procedure calls and distributed databases feel native rather than hacked on. You get a sense of how to build systems that don’t just run on one computer but scale across many without turning into a maintenance nightmare.

Then there’s OTP—the Open Telecom Platform—which might sound like a boring corporate acronym but is actually Erlang’s secret sauce for structuring applications. Armstrong introduces OTP as a set of libraries and design patterns that help you build robust, maintainable systems. It’s like Erlang’s way of saying, “Here’s how to do it right,” so you’re not reinventing the wheel or shooting yourself in the foot.

The book doesn’t shy away from advanced topics either. Multi-core processors are now everywhere, and Erlang’s model scales naturally with them. Armstrong shows how the language’s concurrency primitives leverage modern hardware without the usual headaches.

But don’t expect a gentle ride. Erlang’s functional style and concurrency model can be a steep climb if you’re used to object-oriented or imperative programming. The book demands patience and a willingness to think differently. It’s not a quick fix or a silver bullet, but if you stick with it, you’ll come away with a toolkit that’s rare and powerful.

The second edition, updated around 2013, adds newer Erlang features like maps, better type checking with Dialyzer, and WebSocket support. It keeps the book relevant, though some parts inevitably feel a bit dated given how fast software evolves.

In short, “Programming Erlang” isn’t just a manual; it’s a deep dive into a language designed to solve some of the hardest problems in software engineering. If you want to build systems that don’t melt down under pressure, this book shows you the ropes from someone who helped invent the language itself.