The Soul of Erlang and Elixir • Sasa Juric • GOTO 2019

I feel like this talk does a great job of answering that question - The Soul of Erlang and Elixir by Saša Jurić ( this video )

The Soul of Erlang and Elixir, by Sasa Juric video: this video HN discussion: link Preventing the Collapse of Civilization, by Jonathan Blow video: link HN discussion: link

If you're interested in Erlang/Elixir, you might want to watch this video: this video (GOTO 2019 • The Soul of Erlang and Elixir • Saša Jurić) It shows off the power of the BEAM VM -- and kind of makes you stand back and go "whoa.. how do they do that?"

I feel like the post brushes past the best parts to line the learnings up with container concepts and k8s. The Erlang application/service should not be crashing. A crash happens in a process in a tree of supervisors and each supervisor can have strategies to recover if its child supervisor/process fails. Supervision in Erlang/BEAM is not just microservice infrastructure with restarts. It handles many types of failures knside the application and only if all mitigations repeatedly fail would we crash all the way up to the trunk of the tree and crash the application. If that happens the Erlang heart should be starting it back up or otherwise invoking some last-ditch mitigation. Or if you run Erlang in a container, that's when you'd have your infrastructural stuff restart it. Supervision in Erlang is much more granular and not about restarting the entire service. I think this gives a good view of Erlang resiliency: this video

There are entire languages built upon this model! Anything using the BEAM is a great example. Erlang, Elixir, Gleam, etc. The runtime acts as an event loop and if a specific program is hogging too much time on the CPU, it will get paused and thrown to the back of the execution stack. This is all transparent (relatively) for the developer. Here’s a video if you want to see an example: this video

I can highly recommend Elixir in Action, 2nd ed. This talk by the same author is also a good introduction in video format: this video

No, they're equivalent. It makes no difference whether I calculate in the current process, spawned a process, started a process via the Supervisor, Task.async, or what not. They are all equivalent in the sense that they use BEAM processes. An Elixir, Erlang, or any other developer using the BEAM VM (or at the very least myself since I don't want to generalize) doesn't make a semantic distinction between spawn and Task.async/3 because there is none. The significant differentiation is whether or not the caller is expecting a returned value, if not then Task.start_link can be used instead. I don't need to worry about function colouring because there is none. I also don't need to worry about async vs Task.run like in C# because in Elixir there is none. To be asynchronous in Elixir/Erlang/etc... is to be synchronous. To equate it to modern backends, we basically have a microservice but every service can directly call each other. I think I also might have been talking around you a bit, the BEAM VM sets itself apart from C#'s async/await or the TPL due to its implementation of the actor model. This video by Sasa Juric can explain better than I can the general overview of the BEAM: [1]. But a rough tl;dr, a BEAM process is to the BEAM, what an OS process is to the OS. We don't define a main function as the process supervisor in BEAM spawns processes we define instead and those are our "entrypoints." [1] this video

Runs on the Erlang Virtual Machine, also known as the BEAM. Erlang was built for scalability and fault tolerance of telephone switches by Ericsson in the 80's. Give this a watch, "The Soul of Erlang and Elixir". Covers a lot of what's nice about the underlying platform. this video

I recommend the talk The Soul of Erlang and Elixir by Sasa Juric. this video The thing that Erlang amd Elixir have different is the BEAM VM and its support of concurrent processes at the VM level. So there are some things that they can do that Akka can't. For example, the schedule is preemptive and keeps processes alive even though there may be rogue processes pegging the CPU.