Goodbye Joe

Joe Armstrong is mainly known as the father of Erlang, and the Erlang family has always been relatively small and closely knit. Anyone whose first Erlang conference (usually Erlang Factory, Erlang User Conference, or CodeBEAM) had Joe in the attendance would have a similar reaction. There was a feeling of awe about how accessible the community was. Here you were, and big names like Joe and Robert—who everyone knew by their first names—were right around the same room, friendly, and willing to talk to anybody. You'd feel like you were welcome no matter who you were.

Today, we've learned of Joe's passing away. I wasn't a super close friend of Joe, but I have known him and talked with him at various conferences over the last ten years or so. He's unsurprisingly been a huge influence in my career, and so I thought I should write this little post about him and his impact. My words can't give justice to the man he was, but I felt I needed to write this up.

Around 10 years ago, I used to sling PHP for a dating site, fresh out of a multimedia program in college. I had done a bit of C, Python, Scheme, Javascript, and a few other languages for fun by then. I had been told to figure out how to renew our chat system, and since back then Facebook had written their first one in Erlang (before rewriting it in C++, then buying WhatsApp), my boss threw a copy of Joe Armstrong's Programming Erlang (the first edition) on my desk.

This started my whole story with Erlang, which still goes on today. Joe's book was approachable, the same way he was. He could explain like no other what the principles of Erlang are, what led to its design, and the core approach to fault tolerance that it embodies. It's one of the few language-specific books that is not content with getting you to write code, but lets you understand why you should write it that way. The language didn't just have features because they were cool, it had features because they were needed for fault tolerance. What Joe told you applied anywhere else.

I would end up reading almost everything I could that Joe wrote. Among them:

One of the amazing things Joe mentioned in his texts that was out of the ordinary compared to everything I had read before is that developers would make mistakes and we could not prevent them all. Instead, we had to be able to cope with them. He did not just tell you about a language, he launched you on a trail that taught you how to write entire systems. But Joe's advice and writing went further than this. He was always a huge fan of systematic simplicity, self-contained straightforwardness, and stories from the older times of computing that gave a fresh perspective on everything.

Rather than thinking software is never finished, he wanted software that was so simple it could actually be completed. The strength of your program should be from how extensible and composable its usage would be, not your ability to never be done writing it. On top of that, he wanted code to keep working forever.

One of his blog posts, My favorite Erlang Program, perfectly embodies this. Joe was the kind of person who would take a simple idea, and push it as far as possible, uncovering some great insights on the way. Then he'd share it with everyone.

Joe was a man who would get a thousand ideas a day. Maybe a few of them would be good or practical. For each of these, you'd probably need a whole team to take the underlying principles and make them usable for the rest of the world. But Joe would go on undeterred, always excited, and happy as ever exploring ideas and new concepts all the time. Some would be bad, some would be great. You never really knew what you'd end up with, but you know you'd have passion and great discussions. Should PDFs be both the documentation for a piece of code and the compiled artifact? What if no piece of code ever bore a name and instead you'd just use hashes for all of them and had globally unique everything? It would be good if everyone aimed for inter-program composability rather than whatever it is they are doing right now!

Joe and I, back at Chicago Erlang in 2014, debugging some presentation setup. Photo by Brian Troutwine.

If you were talking with people at a conference, all standing in a circle, and you suddenly got Joe's attention, he'd be inching closer and closer to you, entirely focused, eventually ending up face-to-face with you, the circle crushed by his interest. You'd be able to have his undivided attention for a while, between huge bursts of laughter. He carried this everywhere. You'd invite him to talk about something, and if he had discovered something he felt was more interesting than what he had initially planned, he'd talk about that instead, would go over time if he had to, and everyone was fine with it because, well, that's just Joe. And it was always fun stuff, too.

On a more personal level, Joe was super enthusiastic about some of my first contributions to the language. He wrote the foreword to Learn You Some Erlang, and was always up for a chat. He's had a major influence on my career, and I owe him much. He has unknowingly sent me down a path I am still gladly walking.

Outside of software, Joe really enjoyed music, typesetting, and creative writing, which he would gladly tell you about. He's not known for these to nearly the same extent, but he did it all with the same passion and enjoyment.

He was part of the Erlang landscape, always interested in what people had to say. His passion and enjoyment about the craft, even in his 60s, was still high up at levels I don't even know I ever had or will ever have, and I have to say I am envious of him for that. I don't know what it will be like to have this community without him around. He was humble. He was approachable. He was excited. He was creative. His legacy is not just in code, but in the communities in which he instantly became a central part. He will be missed.

Hello Mike,

Hello Robert,

Goodbye Joe.