During the Code Beam Lite conference you might have had questions that did not get answered, this is your opportunity to get them answered by our expert panel group

Having spent more than 10 years 'learning haskell', on and off, 4 days a month,
4 months a year (in a good year), you know you're better off writing enterprise
Lisp for the rest of your career.

But suddenly out of nowhere you find purpose, and now you need to build a game.

This is that game.

'Let it crash' gets thrown around a lot in the Erlang community. An experienced
programmer (with understandably different experiences) on first encountering
this idea in Erlang is often found asking what we let crash? And what happens
after?

I will attempt to answer this question.

Erlang puts distributed systems programming ideas front and center. We'll also
talk about this in the context of letting processes crash and how that affects the
design of our software.

A standard Elixir distribution comes with fault tolerance and concurrency
primitives that are not available off the shelf in other ecosystems. These
primitives have a learning overhead that is addressed by the excellent
documentation that is available both for Elixir and Erlang/OTP.

But, there isn't much literature describing idiomatic ways to use these
primitives. Most publicly accessible discussions prescribe idioms and style for the
language, but ignore the concurrency primitives that come with it. Perhaps
because the most popular way to use Elixir does not require that you use these
primitives directly.

In this talk, I will unpack and discuss ways to idiomatically use three of
Elixir's OTP behaviours:

GenServer
Supervisor
Registry