Training:

Erlang for Beginners

10-12 May 2021
10:00 - 18:00
Robert Virding

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 for Erlang Programmers

24-28 May 2021
10:00 - 14:30
Robert Virding

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

OTP for Elixir Programmers

24-28 May 2021
10:00 - 14:30
Mikael Muszynski

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

Build an app with Phoenix/LiveView

17 May 2021
10:00 - 14:00
Alvise Susmel

LiveView is a new game-changing library that gives you wings, drastically simplifying and speeding up the development of interactive, real-time Phoenix web applications. LiveView gives you a competitive edge, while allowing you to experiment with faster iterations and faster time to market! In this course you’ll learn how to use Phoenix LiveView while building a real cryptocurrency real-tixfme application.  We’ll start learning LiveView from scratch, but if you’d like to get the most out from this course you’ll need to know a bit of Elixir and Phoenix.   

EXPERTISE

  • Beginner/Medium. No LiveView experience needed, we start from scratch.

 

COURSE DURATION

  • 2 days, 4 hours per day

 

TARGET AUDIENCE

  • Developers who want to learn Phoenix LiveView

 

PREREQUISITES

  • Familiarity with Elixir and OTP, like GenServer and Supervisor.
  • Familiarity with Phoenix, just know how to build a simple Phoenix web app.

OBJECTIVES 

  • Phoenix LiveView to build a real-time application.
  • LiveView with Alpine.js
  • How to build a LiveView web app on the top of an existing Elixir application.
  • Phoenix PubSub

COVERS THE FOLLOWING TOPICS

  • Present an existing Elixir application and introduce the Cryptocurrency Exchanges concepts.
  • Contexts and PubSub
  • First contact with Phoenix LiveView
  • How Phoenix LiveView works
  • Layouts and LiveEEx templates
  • User interactions with bindings, clicks and form events
  • LiveComponents
  • LiveSocket params
  • JS interop with Javascript Hooks. 
  • Real-time JS charts
  • Live Navigation
  • LiveView with Alpine.js

WHY YOU SHOULD ATTEND THIS COURSE

  • Helps you to easily get you up and running with LiveView.
  • This course is not just on how to use Phoenix LiveView. Instead, it's a journey where we go through the full development of a real LiveView application.

Shipping Greenfield Elixir in a Legacy World

17-18 May 2021
14:30 - 18:30
Sophie DeBenedetto and Steven Nunez

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.

Working Effectively with Erlang Legacy Code

18 May 2021
10:00 - 14:00
Brujo Benavides

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.

BEAM VM under the Hood

18 May 2021
09:30 - 17:30
Dmytro Lytovchenko

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.

Unit, System and Property Based Testing

18 Apr - 18 May 2021
09:30 - 17:30
Stavros Aronis

This course introduces best practices around testing, looking at unit and system tests, introducing mocking frameworks and property based testing.

EXPERTISE

  • Intermediate

 

COURSE DURATION

  • 1 day

 

TARGET AUDIENCE

  • Elixir and Erlang developers who want to write better code

 

PREREQUISITES

  • Basic understanding of Erlang and Elixir program structures, OTP applications and releases. Attendees should be able to write basic Erlang or Elixir programs.

OBJECTIVES 

  • Have an understanding of different testing approaches and techniques, and when to use them
  • Know how to use the most commonly used frameworks and tools
  • Understand the principles behind property based testing

 

COURSE OUTLINE

  • Introduction - An introduction to different testing techniques. Unit Testing, System Testing, Continuous Integration, Capacity Planning and other testing Techniques
  • Unit Testing - Introduces Unit testing, code coverage tools, focusing on eunit.
  • Mocking Frameworks - We explain why they are needed, and introduce meck.
  • Property-Based Testing - Introduction to PropEr, and property-based testing in general.
  • Common Test - An introduction to how the system testing and verification with Common Test works.
  • Load - Looks at load testing, back pressure and load regulation. How should systems be load tested, what should you be looking out for, and what do you need to do to stop them from breaking.

Elixir Programming Training for Beginners

10-12 May 2021
09:30 - 17:30
Viktor Gergely

A 3-days introductory course teaching the basics of the Elixir language.

Elixir was Stack Overflow’s most loved, most in-demand and best paid programming language in 2019. Elixir has many real-world uses that are attracting those in the know to add the language to their skill set. This three-day online training is the ideal way to learn the key concepts that will set you on your Elixir programming journey. Along with learning the key concepts of the language, you will discover the essential role of concurrency for BEAM. After completing this course you will be able to write parallel and concurrent Elixir applications that will scale using OTP Behaviours.

Expertise

  • Beginner

Course duration 

  • 3 days

Target audience

  • Software Developers and Engineers without prior experience in Elixir.

Prerequisites

  • Good programming skills in another language such as Java, Perl, Python, node.js, or Ruby
  • Familiarity with server-side software development helpful

Objectives

  • Basic/Sequential/Concurrent Elixir
  • Parallel programming
  • Building, Documenting and Testing Systems using Mix

Covers the following topics 

  • Background Erlang/Elixir
  • Sequential Elixir
  • Unit Testing
  • Concurrent Elixir
  • Process Design Patterns
  • Process Error Handling
  • Funs and High-order functions
  • Data structures (Maps, Structs, Binaries, Protocols)
  • Distributed programming
  • Code updating

Why you should attend this course

  • Helps you get over the hurdle of efficiently understanding the concepts behind Elixir
  • Gets you thinking concurrently about your application
  • 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

 

Trainer 

Robert is Principal Language Expert at Erlang Solutions Ltd. While at Ericsson AB, Robert was one of the original members of the Ericsson Computer Science Lab, and co-inventor of the Erlang language. He took part in the original system design and contributed much of the original libraries, as well as to the current compiler. While at the lab he also did a lot of work on the implementation of logic and functional languages and on garbage collection. He has also worked as an entrepreneur and was one of the co-founders of one of the first Erlang startups (Bluetail). Robert also worked a number of years at the Swedish Defence Materiel Administration (FMV) Modelling and Simulations Group. He co-authored the first book (Prentice-Hall) on Erlang, and is regularly invited to teach and present throughout the world. Robert has taught courses world-wide, focusing on the rationale of Erlang. By explaining why they took the design decisions they did, he shows his students how.