Training

OTP is the middleware, libraries and tools used to design and architect Erlang systems. The Basic OTP course covers the main principles, including process design patterns, supervisors, applications and release handling. It will give the participants the ability to develop and architect Erlang systems. Completion of the Basic or Compete Erlang courses are necessary to enroll in this intermediate course. Basic OTP can be complemented with the one day addons focusing on architecting Erlang systems and Erlang in operations. 

EXPERTISE

• Intermediate 

COURSE DURATION

• 5 days 

TARGET AUDIENCE 

• Software developers & engineers

PREREQUISITES 

• Intermediate user of Erlang, preferably followed by three months of practical experience.
• Ideally you already know about about Erlang Term Storage, concurrent Erlang, error handling and maps and records

WHAT WILL THE ATTENDEE LEARN

• Understand the design principles of OTP 
• Understand OTP behaviours 
• Understand OTP system configuration 
• Awareness of the available OTP applications 

COVERS THE FOLLOWING TOPICS:

• Introduction
• Behaviours
• Generic Servers
• State Machines
• Supervisors
• Event Handlers
• Applications
• System Architecture Support Libraries
• System Principles

WHY YOU SHOULD ATTEND THIS COURSE

• Helps you get over the hurdle of efficiently learning how to build systems with OTP
• Allows you to avoid the pitfalls and borderline cases handled in its libraries
• A cost effective approach to increasing productivity whilst reducing mistakes
• Allows you to design and develop systems using the globally recognised Erlang approach

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 is for you. It will help you understand what happens behind the scenes when building applications using OTP behaviours. 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. We'll have plenty of time to work on labs along the way as you hone your skills and put the theory into practice. About half of the class is either lab work or coding side-by-side with your instructor.

EXPERTISE

• Intermediate

COURSE DURATION

• 5 days

TARGET AUDIENCE

• Software Developers, Engineers and Architects

PREREQUISITES

• Basic knowledge of sequential and concurrent Elixir

OBJECTIVES

• 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 State Machines and others, when to use them, and how to integrate them into supervision trees.
• Get the knowledge about how to deal with load issues applying some techniques like pooling, circuit breakers or producer/consumer solutions.
• Get a deeper understanding about how an Application works and how to create them and work together with others.

COVERS THE FOLLOWING TOPICS

• ETS (a Redis in your beam)
• Behaviours
• Supervision
• Generic Servers
• Generic State Machines
• GenStage
• Applications (and the use of Observer)
• System Principles & Release Handling
• Release Handling

WHY YOU SHOULD ATTEND THIS COURSE

• Helps you get over the hurdle of learning how to build systems with OTP
• Allows you to avoid the pitfalls and borderline cases handled in its libraries
• A cost effective approach to increasing productivity whilst reducing mistakes
• Allows you to design and develop systems using the globally recognised Erlang approach

You’ve built a monolith, but the constraints of your legacy system are slowing you down. You love working with Elixir---Supervisors, built-in distribution, and fault tolerance make it a great fit for the needs of your team and your product---but a rewrite would be expensive and time consuming. If only there was a way to seamlessly integrate a new Elixir application into your ecosystem. Well, there is a way to do exactly that! In this course, we’ll show you how to build autonomous, event-driven systems with Elixir, RabbitMQ and Google Protobuf that let you decouple the data your ecosystem creates from the systems that create them. This opens the path to greenfield applications, and Elixir, in your legacy world.  

EXPERTISE

• Moderate Elixir experience
• Advanced Elixir experience 
• No experience with RabbitMQ or Google Protobuf required

COURSE DURATION

• 1 day

TARGET AUDIENCE

• This course is for anyone that wants to bring Elixir into your existing tech stack. 
• Those interested in event-driven design.
• Those interested in working with message brokers like RabbitMQ

PREREQUISITES

• Moderate Elixir experience is a plus but no prior knowledge of RabbitMQ or Google Protobuf is assumed.

OBJECTIVES 

• Elixir and Inter-Process Communication create the blueprint for integrating Elixir into your existing tech stack. By the end of the day, you’ll understand when and why to reach for IPC and how to leverage Elixir’s fault-tolerance and concurrency capabilities to create an event-driven system that seamlessly brings Elixir into your existing ecosystem.
• You’ll learn how to identify scenarios that can benefit from IPC, and then we’ll dive right into building an IPC system. Starting with the basics of RabbitMQ and how to interact with it in Elixir, we’ll move on to discussing the challenges of message synchronization and how Google Protobuf solves some of these problems.
• You'll see how Elixir's concurrency and fault tolerance features--in particular supervision trees and the "let it crash" mentality--make Elixir the perfect fit for building IPC. We'll wrap up with a look at some deployment concerns and strategies.

COVERS THE FOLLOWING TOPICS

• Inter-Process Communication (IPC) and event-driven design
• Working with RabbitMQ and Elixir
• Working with Google Protobuf and Elixir

WHY YOU SHOULD ATTEND THIS COURSE 

• You’ll have a path forward to integrating greenfield Elixir applications into your legacy system, in a way that your team can deliver on, while still meeting the needs of your business. 
• You’ll learn how to think about event-driven systems, by creating an ecosystem of rich messages whose utility extends beyond their source application, moving you towards a Microservice-Oriented Architecture.
• You’ll see all the ways in which Elixir is the perfect fit for such a system.

So you just joined a massive project with tons of poorly-maintained Erlang code. DON'T PANIC! This tutorial will teach you all the tools and techniques you need to start working on it confidently and productively.

You will learn how to use tools like the compiler, common_test, xref, dialyzer, elvis, hank, the formatter and others in large codebases which are generally hard to work on. These tools and some of the techniques will increase your confidence and help you work more efficiently.
 

EXPERTISE

• Intermediate

COURSE DURATION

• 4 hours

TARGET AUDIENCE

• Erlang developers that work (or plan to work) in legacy systems.

PREREQUISITES

• Erlang/OTP 22 (or newer), github, and a text editor

COVERS THE FOLLOWING TOPICS

• Improving systems in an iterative way
• Testing Frameworks: Common Test, Eunit
• Cross-reference Analyzers: Xref
• Discrepancy Analyzers: Dialyzer / Gradualizer
• Linters: Elvis / rebar3_lint
• Dead Code Removers: Hank / rebar3_hank
• Security Analyzers: PEST

WHY YOU SHOULD ATTEND THIS COURSE

• Increases your confidence in dealing with large and complex systems.
• Gives you tools to help you build better applications.
• Gets you thinking in maintainability.
• Helps you follow Joe’s recommendation of writing Beautiful Code.

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.

OBJECTIVES

Understand how the BEAM works under the hood Fine-tune it and optimise 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 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.

COURSE OUTLINE

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.