Robert Virding

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

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.

OBJECTIVES

• A better understanding of tools for building and maintaining systems
• Understand the basics of profiling and debugging of running systems

OUTLINE

This two-day course presents some more advanced tools for building and maintaining applications with Erlang. It also gives insight into the tracing tools in the system which allow support engineers to inspect and monitor running systems. The course contains the following topics:

• Parse Transforms
• Profiling
• Emulator Flags (BEAM introduction)
• Observer
• Tracing & Debugging (Trace BIFs & Match Specifications; The dbg Tool; Recon, Redbug).

Use Erlang's strengths to create software that is fault-tolerant, scalable and deployable in a distributed network.

OBJECTIVES

• Understanding of the basics of Erlang
• Read/Write/Design Erlang Programs
• Provides basics needed to attend the OTP course

PREREQUISITES

Good programming skills in another language.

TARGET AUDIENCE

Software Developers & Engineers.

COURSE OUTLINE

Basic Erlang is a three-day introductory course.

The course contains the following topics:-

• Background
• Basic Erlang
• Erlang Shell
• Sequential Erlang
• Concurrent Erlang
• Process Design Patterns
• Process Error Handling
• Modules & Processes
• Data Structures
• Funs and High-Order Functions
• Macros
• Distributed Programming

How do systems built in Erlang, Elixir or any other BEAM Language differ from other systems? To start with: They are designed from the bottom up to run 'forever.’ They are designed from the bottom up to expect, and recover from errors. They are expected to evolve. They scale seamlessly.

How is all of this achieved? - the answer is simple - by making systems from sets of isolated communication processes, and by treating errors and code as first class objects that can be sent in messages over a network.

In this tutorial, Robert will introduce what he calls the "Erlang way of thinking." He will cover: 

• Basic data types
• Sequential programming
• Concurrent programming

In Basic data types & sequential Erlang, he’ll introduce the foundations and talk about Modules, Functions and Pattern Matching. Once you've understood the basic pattern matching mechanism the rest is easy.

In concurrent programming, we'll talk about processes and their life span. You will look at sending and receiving messages, selective reception, and passing data in the messages. Robert will conclude this section by introducing the simple but powerful error handling mechanisms in processes which help detect and isolate failure.

Time permitting, we will cover distribution, showing you how by doing it right from the start or with very few changes, you can write a program intended to run on a single VM and distribute it in a cluster.

OBJECTIVES

To learn the Erlang way of thinking when architecting and developing systems.

PREREQUISITES

Programming experience in at lease a couple of programming languages.

TARGET AUDIENCE

Developers and architects who are interested in the principles which make Erlang, Elixir or other BEAM-based languages unique.

An introductory course introducing the key concepts in Erlang. They include its functional heritage, concurrency and error handling. The course provides most prerequisites to attend the OTP course and a range of follow up courses which can be used to guide developers through advanced topics focusing on Erlang architectures and operations.  Together, they are great for those that need to be introduced to Erlang and use it in commercial projects. 

EXPERTISE

• Beginner

COURSE DURATION

• 3 days

TARGET AUDIENCE 

• Software developers, engineers and architects

PREREQUISITES

• Good programming skills in another language

OBJECTIVES

• Understanding of the basics of Erlang
• Read/Write/Design and observe Erlang Programs
• Learn how to think concurrently and handle errors
• Get an understanding of best development and design practices
• Provides foundation needed to attend the OTP course

COVERS THE FOLLOWING TOPICS

• Why should you be using Erlang?
• The Shell, Types and Constructs
• Sequential Programming
• Unit Testing
• Thinking Concurrently
• Process Design Patterns
• Process Error Handling and Fault Tolerance
• Functional Programming Constructs
• Maps and Records
• ETS tables, the Redis of the Erlang world
• Good Design Practices

WHY YOU SHOULD ATTEND THIS COURSE

• Helps you get over the hurdle of efficiently learning Erlang
• Gives you all of the knowledge you need to dive deeper in advanced subjects
• Stops you from doing the typical beginner errors
• Gets you up to speed with the development workflow
• Gets you thinking the Erlang way

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

While Erlang is a powerful programming language used to build distributed, fault tolerant systems with requirements of high availability, these complex systems require middleware in the form of reusable libraries, release, debugging and maintenance tools together with design principles and patterns used to style your concurrency model and your architecture.

In this tutorial, Robert will introduce the building blocks that form OTP, the defacto middleware that ships with the Erlang and Elixir distributions. He will cover OTP’s design principles, describing how they provide software engineering guidelines that enable developers to structure systems in a scalable and fault-tolerant way, without the need to reinvent the wheel.

Note: We recommend you take this tutorial in conjunction with the one on Thinking Concurrently.

OBJECTIVES

To learn the Erlang way of thinking when architecting and developing systems.

TARGET AUDIENCE

Developers and architects who are interested in the principles which make Erlang, Elixir or other BEAM based languages unique.

PREREQUISITES

Either:

• Having attended the Thinking Concurrently tutorial in the morning
• Basic coding experience in Erlang or Elixir through side projects or self-learning

Come with a laptop and the latest version of Erlang installed. If you have time, get the Erlang mode working on your editor of choice.