OTP for the seasoned Erlanger

25-27 May 2020
09:00 - 17:00
Robert Virding

Learn the prevailing Erlang design patterns called OTP behaviours.

Erlang co-creator Robert Virding will cover Erlang design patterns such as generic behaviours, finite state machines and event handlers. You will also learn how to develop systems using the supervisor and application behaviours patterns, so you can construct maintainable and fault-tolerant software.

Upon completion of this course, you will be able to extend it all, by devising your very own behaviours.



  • Use existing Design Patterns supported by Erlang and OTP.
  • Apply Generic Behaviours, Finite State Machines and Event handler Patterns.
  • Use the Supervisor and Applicaton Behaviours Patterns.
  • Write your own Design Patterns.
  • Structure large Erlang based systems.



Existing experience using sequential and concurrent programming with Erlang on projects.



This course is aimed at experienced Erlang software developers and designers who need to understand behaviours.


This course introduces the need and advantages of using middleware in the development of massively concurrent, distributed, fault-tolerant real-time systems in Erlang. It looks at Erlang's evolution, and how it helped form OTP. Further, this gives an overview of the components that make up OTP. They are Erlang, a set of behaviours, and rules and design principles to use them. OTP comes with many ready built applications and tools useful for large scale software design. They are introduced in this course.


Erlang processes display similar properties. In the Open Telecom platforms, these properties have been abstracted in a group of generic library modules, also called OTP behaviours. This section introduces the concept of behaviours, and through examples of abstraction, shows their need and advantages.


Generic servers implement the Client-Server behaviours in OTP. This section introduces the most commonly used behaviour in Erlang based applications.


The finite state machines behaviour in Erlang is used to implement state transitions in processes based on incoming events. This behaviour is commonly used when implementing protocol stacks.


Supervisors are a behaviour whose only task is to start other Erlang behaviours and monitor them for abnormal termination. This is a vital section in the understanding start and restart strategies in Erlang.


Erlang has ready-built event managers. Event handlers are behaviours who subscribe to events sent to specific managers, allowing several actions to take place based on one single event. Event handlers can be changed on the fly, as well as added or deleted from a specific manager.


This section introduces the application behaviour, used for packaging Erlang resources. Resources can vary from libraries to process clusters and can be configured to run on a single processor or be distributed on a set of nodes.


There will be times where we want to implement our own behaviours, or for efficiency reason, use simple Erlang processes. This section looks behind the scenes on how behaviours are implemented and explain how to implement your own.


The System Principles section describes how Erlang applications are coupled together in a release and started as a whole. Sections include creating release files, bundling up the software including the virtual machine, and running Erlang on target and embedded hosts.

Elixir OTP Behaviours: Behind the Scenes

25-27 May 2020
09:00 - 17:00
Mikael Muszynski

So you've built and deployed a Phoenix application backed by Ecto and Postgres, and come to the conclusion that you love it. If you are looking at progressing to the next level, this hands-on training will help you get to the next level. In it, we will focus on building applications using OTP behaviours and architecture guidelines. Learn about the battle-tested abstractions needed to build back-end, fault-tolerant systems that will run for years and scale to billions of users.



When you've completed this class, you'll have a deeper understanding of how to architect back-end systems and micro-services that you can access and use from Phoenix. Learn why we need behaviours such as Generic Servers, Generic Finite State Machines and others, when to use them, and how to integrate them into supervision trees.



You should have basic knowledge of Elixir, and whilst not necessary, it would be useful if you have developed a Phoenix application.



This is an intermediate level class scheduled to get you up and running with OTP.


Topics include:

  • Life before OTP
  • OTP architecture
  • Behaviours
  • Supervision
  • GenServer
  • GenStateMachine
  • Other behaviours (GenStage, GenFlow, Event Handlers, etc)
  • Optimising for performance
  • ETS (a Redis in your beam)
  • Load regulation and back-pressure (fuse, safety valve)

Clueful Elixir with Kubernetes

27 May 2020
09:00 - 17:00
Bryan Hunt

Deploying, running, operating and debugging Elixir and Erlang applications on Kubernetes doesn’t have to be a big deal once you know a couple of basic tricks and patterns.

In this one-day tutorial, you will learn to build, deploy, scale and cluster Elixir applications on Kubernetes.



When you've completed this tutorial, you will:

  • Have a deeper understanding of Kubernetes
  • Know how to operate an Elixir cluster deployed on Kubernetes
  • Know how to set up monitoring Know how to debug issues
  • Know how to template configuration for deployment in multiple environments
  • Learn the techniques for keeping secrets secret

Most of the class will be live coding together. You'll have plenty of time to work on labs along the way as you hone your skills. About half of the class is either lab work or coding side-by-side with your instructor.



Attendees should have a basic understanding of Elixir applications, releases, distributed Erlang, and Docker.

Please have docker for Mac (edge) installed on their machine (Kubernetes supported out of the box)(preferable), a working Kubernetes instance, or use a provided GKE Google Kubernetes Engine instance.



Elixir/Erlang developers with basic knowledge of Docker wishing to expand their operational ability of running BEAM applications on Kubernetes.


  • Best practice for building docker images of Elixir applications
  • Using distillery for building releases
  • Using libcluster for automatically forming Elixir clusters
  • Integrating Prometheus/Grafana monitoring
  • Debugging deployment issues
  • The characteristics of the different Kubernetes controllers
  • How to leverage Kube DNS
  • Autoscaling
  • Working with dependencies and private repositories
  • Startup failure and health checks
  • Exposing Kubernetes applications to the internet (GKE)

BEAM VM under the Hood

27 May 2020
09:00 - 17:00
Dmytro Lytovchenko

Everything you wanted to know about the BEAM but were too afraid to ask.

Join us for a guide for operations and development teams. Through examples and hands-on exercises, we will showcase how to manage the BEAM VM in operational environments, optimising for memory utilisation and performance when using Erlang or Elixir.



Understand how the BEAM works under the hood Fine-tune it and optimise its settings for throughput and memory use.



Experience in developing and supporting languages running on the BEAM including Erlang and Elixir.



The course is aimed at experienced developers and devops engineers, helping them pre-empt and address behaviours which arise as the result of VM specific settings, be it disruption of soft real time properties as a result of garbage collection or bottlenecks in the scheduler.


Introduction to the BEAM

The highlights of the BEAM Virtual Machine, highlighting the features which make it stand out in comparison to other VMs.

Processes under the hood

Explore at processes, how memory is allocated, managed and garbage collected. We look at some of the bottlenecks in the BEAM caused by concurrency, describe how they manifest themselves, and how to avoid them.

The process scheduler

Understand how the schedulers work, how it scales on multi-core architectures and what its limitations are. We cover how the run queues can be monitored and manipulated, and how process priorities can backfire.

Memory management

In this section, we look at different memory types including system, atom, binary, code and ets tables. We will cover how (and why) you should monitor memory, and how issues can arise. We will also cover how the garbage collector works, focusing if, and when optimizations are necessary.

Tweaking and fine-tuning

How can the BEAM VM be tweaked and what possible areas for fine-tuning are available to you? We'll look at some of the most obscure flags which can come in hand, allowing for specific optimisations on a VM level, be it to increase I/O or throughput in virtualised environments.

Unit, System and Property Based Testing - Break your Erlang system before your customers do!

27 May 2020
09:00 - 17:00
Stavros Aronis

This course introduces best practices around testing, looking at unit and system tests, introducing mocking frameworks and property based testing.



After this tutorial, you will

  • Have an understanding of different testing approaches and techniques, and when to use them
  • Know how to use the most commonly used frameworks and tools
  • Understand the principles behind property based testing

The class will be a mix of presentations, live coding and exercises.

You'll have plenty of time to work on labs along the way as you hone your skills, getting you started on your journey in testing systems which never fail.



Attendees should have a basic understanding of Erlang and Elixir program structures, OTP applications and releases. They should be able to write basic Erlang or Elixir programs.



Elixir/Erlang developers wishing to fast track their understanding on how to test programs running on the BEAM using the BEAM.


Introduction - An introduction to different testing techniques. Unit Testing, System Testing, Continuous Integration, Capacity Planning and other testing Techniques

Unit Testing - Introduces Unit testing, code coverage tools, focusing on eunit.

Mocking Frameworks - We explain why they are needed, and introduce meck.

Property-Based Testing - Introduction to PropEr, and property-based testing in general.

Common Test - An introduction to how the system testing and verification with Common Test works.

Load - Looks at load testing, back pressure and load regulation. How should systems be load tested, what should you be looking out for, and what do you need to to to stop them from breaking.

OTP Certification


The OTP Certificate provides proof that the holder understands the core concepts of Erlang/OTP, and is ready to apply the knowledge to building systems.

The certification is aimed at people who have completed the four-day “Complete OTP” course, preferably with practical experience after that.

The exam consists of a 90 minute multiple-choice questionnaire.

Erlang Certification

The Erlang Certificate provides proof that the holder understands the core concepts of the Erlang programming language, and is ready to move on to the more advanced levels of Erlang study and usage. The certification is aimed at people who have completed the five-day “Complete Erlang” course, preferably with practical experience after that. The exam consists of a 90 minute multiple-choice questionnaire.