OTP for the seasoned Erlanger

02-04 Oct 2019
09:00 - 17:00
Francesco Cesarini

You will learn the prevailing Erlang design patterns called OTP behaviours. We 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 application 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 course 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.

  • Behaviours
  • Generic servers
  • Finite State Machines
  • Supervisors
  • Event Handlers
  • Applications
  • Special Processes
  • System Principles

Professional LiveView and OTP

02-04 Oct 2019
09:00 - 17:00
Bruce Tate

From the coming books Designing Systems with OTP and the second edition of Programming Phoenix, this course will walk you through the strategies you'll need to build web applications without JavaScript. You can focus on what's happening on the server, even as you build the most interactive of applications.



When you've completed this class, you'll have a deeper understanding of Elixir's OTP and Phoenix LiveView. You'll be able to think about program design, especially building your project in layers so that the LiveView code you create is easy to maintain, letting you deal with one piece of complexity at a time. EXPECTATIONS We'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.



This is an intermediate level class scheduled to get you up and running quickly using LiveView. You should know Elixir, and it would help for you to know Phoenix as well.


We'll cover a strategy for rapidly building applications the Elixir way, including: 

  • Designing Applications in Layers
  • The LiveView lifecycle
  • JavaScriptless validations with changesets
  • Integrating OTP
  • Working with channels and events
  • Programming simple animations

Crash course in Elixir

30 Sep 2019
09:00 - 17:00
Chris Bell

Are you interested in Elixir, but you haven't yet learned the language? Are you an imperative language programmer who's finding it tricky to get a handle on the functional approach? Do you find yourself wishing that Elixir had a "for loop"?

We've developed a one-day workshop to get you past the learning curve. Starting with the absolute fundamentals of Elixir's datatypes, we'll take you through every aspect of the language that tripped us up when we were learning.



By the end of the day, you will be able to confidently solve complex business problems faster and more reliably than you'd have ever believed possible. Learning to build solutions on top of immutable data structures requires a new way of thinking, and we've designed our workshop to get you thinking that way quickly.



Some past programming experience in a language such as JavaScript, Ruby, Python, Java or C++.



The course is not for complete beginners. You should be comfortable programming in some language, but what language is unimportant. People whose proficiency lies outside the functional paradigm will probably get the most out of the course, but functional programmers who are new to Elixir will find the course to be a useful survey of the main features of the Elixir ecosystem.


  • All the built-in datatypes: numbers, binaries (strings), lists, maps, structures, tuples, and atoms
  • Functions: anonymous functions, named functions, and higher order functions
  • Pattern matching: This is a hugely powerful technique
  • Elixir tooling: How our projects are organised, the build system, the dependency management system, the test framework, and the rich documentation system
  • How to model problems using functional patterns instead of Object Oriented patterns

RabbitMQ Express

30 Sep 2019
09:00 - 17:00
Brett Cameron

Learn about the main concepts in RabbitMQ in the one day RabbitMQ Express training course taught by the RabbitMQ expert at Erlang Solutions. The training course will cover the following topics:

  • RabbitMQ fundamentals
  • Building systems with RabbitMQ
  • Extending RabbitMQ with plugins
  • Optimising & troubleshooting RabbitMQ



Experience in at least 1 programming language of choice (junior, intermediate, senior).



  • Software developers
  • Solution architects
  • DevOps engineers



  • Understanding AMQP concepts
  • Building distributed messaging systems with RabbitMQ
  • Performance tuning RabbitMQ
  • Deploying real world, resilient RabbitMQ architectures
  • Troubleshooting and monitoring
  • Understanding RabbitMQ internals
  • Customising RabbitMQ with plugins


Building resilient distributed systems with Elixir

30 Sep 2019
09:00 - 17:00
Chris Keathley

One of the most exciting features of Elixir is its ability to connect multiple nodes together. Because distribution is built directly into the language’s runtime, those of us in the Elixir world have access to a number of powerful abstractions for building distributed systems.

However, distributed Erlang comes with several caveats and warnings. We will demystify some of the warnings while reiterating others.

In this tutorial, participants will get hands on experience with distributed Erlang through building real solutions to real world problems.

You will learn how to harden their solutions against network and hardware failures using a test harness designed to inject failures into clusters. Whilst the goal is to provide an understanding of the primitives available in Erlang and Elixir for building distributed systems, we’ll also discuss some of the popular libraries available in the BEAM ecosystem.



  • Provide insights into the tools available for building distributed systems
  • Learn patterns for building consistent and eventually consistent systems
  • Experience the different types of faults that you’ll see in the real world



You should have a working understanding of Supervisors, GenServers, and other primitives in Elixir and Erlang.



Intermediate Erlang or Elixir developers who want to take advantage of the clustering abilities in OTP.


The tutorial is broken into 4 distinct pieces of work. Each section builds on the previous and endeavours to provide real-world scenarios.

  • Connecting nodes, sending messages, and handling faults
  • Building low latency APIs with replication
  • Scaling replication with eventual consistency
  • Taking advantage of your computer by distributing work across the cluster