Training

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.

OBJECTIVES

• 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

PREREQUISITES

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

TARGET AUDIENCE

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

COURSE OUTLINE

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.

BEHAVIOURS

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

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

FINITE STATE MACHINES

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

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 understanding start and restart strategies in Erlang.

EVENT HANDLERS

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.

APPLICATIONS

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.

COMPLIANT PROCESSES

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.

SYSTEM PRINCIPLES

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.

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.

OBJECTIVES

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.

PREREQUISITES

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

TARGET AUDIENCE

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

COURSE OUTLINE

Topics included:

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

Web development does not have to hurt! In this one-day class, you will learn to build highly interactive web applications using Phoenix LiveView. Instead of coding JavaScript to move data between the client and server, you'll rely on the power of Phoenix and Elixir to do the hard work for you.

OBJECTIVES

When you've completed this tutorial, you'll have a deeper understanding of 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. Most of the class will be live coding together. 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.

PREREQUISITES

• Come ready to code with us!
• Have a working installation of Elixir, git (with a GitHub account), Postgres and Phoenix (1.4 or higher)

TARGET AUDIENCE

• Early intermediate to advanced intermediate Elixir developers 
• With no to little experience in LiveView
• Know how to use git or take the free GitHub tutorial
• Phoenix experience is not required

COURSE OUTLINE

This tutorial will cover the following:

• The LiveView lifecycle
• Building pages online and in templates
• Sending Events with HTML
• Building back-end models
• Building software in layers

A guide for operations and development teams Everything you wanted to know about the BEAM but were afraid to ask. Through examples and hands on exercises, we will showcase how to manage the BEAM VM in operational environments, optimizing for memory utilisation and performance when using Erlang or Elixir.

OBJECTIVES

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

PREREQUISITES

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

TARGET AUDIENCE

The course is aimed at experienced developers and devops engineers, helping them pre-empt and address behaviour 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.

COURSE OUTLINE

Intro 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 virtualized environments.

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.

OBJECTIVES

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
• 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.

PREREQUISITES

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.

TARGET AUDIENCE

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

COURSE OUTLINE

• 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
• Autoscalling
• Working with dependencies and private repositories 
• Startup failure and health checks
• Exposing Kubernetes applications to the internet (GKE)

If you're considering using Erlang or Elixir for your next IoT device or just wanting to learn more about embedded systems, this class will give you a tour of the two major BEAM-powered embedded system projects. Both projects build on the rock solid reliability and productivity of the Erlang VM, and are used in industrial projects around the world.

OBJECTIVES

• To get real practical experience with embedded systems
• Know why the BEAM virtual machine is a good fit for such projects
• Understand the basic concepts and characteristics of embedded systems
• Familiarity with Nerves and GRiSP platforms, including the foundation to keep developing your own project
• Have fun!

PREREQUISITES

• A Mac or Linux laptop. Windows laptops with a Linux VM can work, but verify USB connectivity
• Have a working installation of Erlang and Elixir
• Working USB ports - check if blocked by a corporate firewall or if you have USB C, bring an adapter
• No hardware needed! We'll provide a software installation checklist a week before the training

TARGET AUDIENCE

This tutorial is for those with: * basic knowledge of Erlang or Elixir * familiarity with gen_server/GenServer * none or only a little experience with either GRiSP or Nerves)

COURSE OUTLINE

This is a unique class led by the creators of both Nerves and GRiSP that will not only get you started with both projects, but will also help you understand the differences and tradeoffs. The class is hands-on.

We'll provide hardware and labs for you that cover the basics, interacting with low level hardware, networking devices, and interoperability.

OVERVIEW

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.

TARGET AUDIENCE

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

WHAT YOU NEED TO KNOW

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

Dates to be arranged with certification takers on a 1-2-1 basis. We will work with you to ensure that it is as convenient for everyone as possible.

OVERVIEW

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.

TARGET AUDIENCE

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

WHAT YOU NEED TO KNOW

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

Dates to be arranged with certification takers on a 1-2-1 basis. We will work with you to ensure that it is as convenient for everyone as possible.