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