Most teaching and modelling revolves around synchronous techniques and solutions, as they are easier to grasp in the beginning. As multi-core and distributed architectures is becoming the norm the need for asynchronous design is increasing.

This is where old school protocols starts to shine again. The dragon of telecommunications is coming to life again.

All systems, but in particular asynchronous ones, can benefit from a more thorough focus on the interaction (aka the protocols) between the entities in the system. Programming the internals of a component - be that an object or a process - is not the hard part; making sure that the components can work together is the real challenge.

For synchronous systems you can avoid looking at the protocols for a long time, only to realise that you need them when things are becoming complex.

That approach will not even get you started with asynchronous systems, which is one of the reasons that many people find them hard to work with. It also has the effect that technologies, like Erlang, that embraces the asynchronous model can be hard to learn how to use to ones advantage.

In this talk we will spend most of the energy on how to design systems with asynchronous message passing between processes that do not share any memory.

We will see how The Golden Trinity of Erlang - share nothing processes, fail-fast and failure handling - relates to asynchronous protocols and how this mix of features provides a good solution for exploitation of the new multi-core and distributed architectures.

Talk objectives:

• Show how to model asynchronous designs with Message Sequence Charts (aka Sequence Diagrams).
• Show how Erlang's programming model fits implementation of asynchronous protocols in a robust way.
• Explain why embracing failure is necessary to thrive on modern architectures.

Target audience: People looking for a better way of crafting systems, asynchronous or synchronous.