ElixirZA
ElixirZA
A community of Erlang & Elixir enthusiasts from South Africa 🇿🇦 and the broader African continent 🌍.
Elixir is a programming language that runs on the Erlang runtime (also known as BEAM / OTP). It is not the oldest BEAM language (that would be Erlang), neither is it the youngest (there are several), but it is the most fun to work with.
Elixir is used in production in large software systems, e.g. Discord. And the underlying Erlang runtime powers WhatsApp, and a great deal of the infrastructure (switches) that make up the modern telco networks that we all rely on.
What makes Elixir useful is the underlying Erlang runtime's "let it crash" philosophy, shared by all BEAM languages, where
The "let it crash" approach gives us a way to build systems that are fault tolerant, without the need to resort to defensive coding. If a process fails, it fails, but it doesn't bring down the whole system.
Better still... by isolating sequential programs into independent processes, the Erlang runtime makes it trivial to run code concurrently. So the code that was written to run on your own machine can also run efficiently on a different machine with many more cores, without requiring any changes to your code.
The same mechanisms for distributing work among CPU / GPU cores also helps make it relatively simple to scale Elixir applications among different machines, which may be running in very different geographic locations.
In this way, Elixir gives us a way to gradually turn simple programs, running locally, into large, distributed systems, without forcing us to change our mental models as we scale to bigger workloads.
Want to know more? Have a look below at some of our favourite talks / resources to get some more context around Elixir & Erlang, and to wrap your head around the underlying "let it crash" philosophy.
Some of the resources we've found to be most helpful for wrapping your head around Erlang / Elixir / The BEAM.
Why are we even here?
In this seminal talk from 2019, Saša Jurić demonstrates in a practical way how message-passing concurrency allows us to build rock-solid fault-tolerant systems, that can handle errors and crashes that would have been very difficult, or impossible, to pre-empt in most other programming languages.
https://www.youtube.com/watch?v=JvBT4XBdoUEJosé Valim explains what initially brought him to create Elixir on top of the Erlang Virtaul Machine (the BEAM), which he started working on in 2012. He shows how it can be used to create a fault-tolerant, distributed systems, without much of the complexity that one might have expected.
https://www.youtube.com/watch?v=lxYFOM3UJzoThis vintage promotional video, from the 1980's, from Ericsson's Computer Science Laboratory, introduces Erlang for the first time. Joe Armstrong, Mike Williams and Robert Virding demonstrates its use for routing landline phone calls and handling the errors that may be expected to occur.
https://www.youtube.com/watch?v=xrIjfIjssLETake your time to geek out on some of the finer implications of message-passing concurrency.
In this short & approachable talk Francesco gives an eloquent overview of the history and core ideas behind the development of Erlang.
https://www.youtube.com/watch?v=SOqQVoVai6sIn this classic talk from 2018, Joe Armstrong discusses the problem of writing fault tolerant software, giving a short overview of his own involvement in writing Erlang. He discusses the implications of message-passing concurrency and the elegant architectural design solution of just letting things crash (when they are running in independent processes) to make it easy to reason about errors and their implications in our code.
https://www.youtube.com/watch?v=TTM_b7EJg5EWritten late in his career, this 2003 thesis can be seen as Joe Armstrong's treatise on the problem of Fault-tolerant Computing. He goes to great lengths to discuss the historical context within which Erlang originated, the architectural philosophy behind it, as well as the nut-and-bolts details of the resulting implementation.
https://erlang.org/download/armstrong_thesis_2003.pdf
One of the creators of Erlang gives an easily digestible overview of the BEAM (the Erlang runtime), aimed at developers and system architects. He discusses the main features and highlights the most common pitfalls one can expect to encounter when running applications on the BEAM.
https://www.youtube.com/watch?v=_Pwlvy3zz9M
“Make it work, then make it beautiful, then if you really, really have to, make it fast. 90 percent of the
time, if
you make it beautiful, it will already be fast. So really, just make it beautiful!”
- Joe Armstrong