Joe Armstrong pioneered the engineering of fault tolerant, concurrent systems.

Throughout his career he asked and answered:

How can we program systems which behave in a reasonable manner in the presence of software errors?

He surmised that:

Large systems will probably always be delivered containing a number of errors in the software, nevertheless such systems are expected to behave in a reasonable manner.

And Joe wanted to build a foundation that would allow us to meet this enormous challenge.

First, Joe and his colleagues at Ericsson established the principles by which they would build large scale distributed systems that would behave reasonably in the face of faults and scale to the size of enormous problems. Then they built the Erlang language and ecosystem to implement these principles. Ultimately, they ended up building a system by which applications might run forever .

I recommend reading Joe Armstrong’s thesis, Making Reliable Distributed Systems in the Presence of Software Errors (2003), from which all of these quotes are taken. I think Chapters 1 through 5 are particularly insightful. Here is a section from the introduction of Chapter 3, describing Erlang’s view of the world:

The Erlang view of the world can be summarized in the following statements:

• Everything is a process.

• Processes are strongly isolated.

• Process creation and destruction is a lightweight operation.

• Message passing is the only way for processes to interact.

• Processes have unique names.

• If you know the name of a process you can send it a message.

• Processes share no resources.

• Error handling is non-local.

• Processes do what they are supposed to do or fail.

The use of processes as the basic unit of abstraction is motivated by the desire to make a language which is suitable for writing large fault-tolerant software systems. The fundamental problem which must be solved in writing such software is that of limiting the consequences of an error— the process abstraction provides an abstraction boundary which stops the propagation of errors.

“Everything is a process” in Erlang, creating conceptual integrity throughout the system. A tree of processes with “supervisors” at the top and “workers” processing messages they receive can be both very scalable and fault tolerant. Isolation of processes prevents errors from propagating from one to the other. This creates well-defined locations for application behavior, such as Erlang’s “let it crash” model for error handling (the supervisor can restart the worker). Communicating via messages and sharing no resources improves concurrency. Lightweight process creation and destruction improves efficiency and responsiveness of applications to changing workloads.

Our industry owes a lot to Joe’s creativity, enthusiasm, and work. While I have only dabbled with Erlang, I have used many of these same principles in Akka and other message-oriented environments. The experience can be wonderful. If you use technology like message passing, supervision trees, or actor models, you use them too.

Thank you, Joe.


p.s. Joe Armstrong passed away this weekend. Joe was a creative, kind, and generous man who will be missed by many (learn more). My sincere condolences to the Armstrong family and friends.