Tutorials:

Architecting Reactive Systems for Scalability and Availability

01 Nov 2021
09:00 - 13:00
Francesco Cesarini

Learn how to architect fault-tolerant, scalable, soft, real-time systems with requirements for high availability.

In this tutorial, we will look at the steps needed to design scalable and resilient systems. The lessons learnt apply to the Erlang ecosystem, Elixir included, but are in fact technology agnostic and could be applied to most stacks, including Scala/AKKA, .net and others.

It has to be event driven and react to external stimulus, load, and failure. It must always be responsive. You have heard many success stories that suggest Erlang is the right tool for the job. And indeed it is—but while Erlang is a powerful programming language, on its own, it’s not enough to group these features together and build complex reactive systems. To get the job done correctly, quickly, and efficiently, you also need middleware, reusable libraries, tools, design principles, and a programming model that tells you how to architect and distribute your system.

 

EXPERTISE

Intermediate

 

TARGET AUDIENCE

Software Developers and architects

 

DURATION

3,5 hours

 

PREREQUISITES

Software development experience is a must, as is the understanding of data consistency models. Experience or exposure to designing and architecting systems is a benefit, but not a prerequisite.

OBJECTIVES

We will focus on:

  • Distribution: This section covers how to break up your system into manageable microservices. How do you collect these micro services into nodes, which together form distributed architectural patterns, giving you your end-to-end system? What network connectivity do you use to let them communicate with each other?
  • Interfaces and state: This section covers how you define your service interfaces. What data and state do you distribute across your nodes, clusters, and data centers? And if requests fail across nodes, what is your recovery strategy?
  • Availability: You need at least two computers to make a fault-tolerant system. When dealing with fault tolerance, you have to make decisions about resilience and reliability. This section covers techniques needed to make sure your system never fails and the trade-offs you need to make in your design.
  • Scalability: When you picked your distributed pattern, decided how to distribute your data, and made choices on fault tolerance, resilience, and reliability, you also made trade-offs on scalability. This section covers the decisions you have to make and how they affect scalability, as well as how to deal with capacity planning, load regulation, and back pressure.
  • Observability: This section covers the importance of visibility on both a business level and a system level. To achieve five-nines availability, you need preemptive support and automation. To trigger automation, you need to know the state of your system and be able to react to it as quickly as possible. This includes metrics, alarms, and notifications.

The tutorial is based on the last four chapters of Designing for Scalability with Erlang/OTP by Francesco Cesarini.

Real Time Applications: Beyond the UI

02 Nov 2021
09:00 - 17:00
Stephen Bussey

This course will give you the building blocks necessary to build scalable real-time applications. If you are working on an application that has real-time features, or you want to ship more reliable applications, this course is for you.

We’ll focus on the engine that sits behind great real-time apps. You’ll build a data pipeline from source to user backed by GenStage. We’ll connect multiple nodes together to see how our servers can work together over PubSub. All applications need to be deployed, so we’ll cover deployment problems that are specific to real-time applications. Of course, we’ll be using Phoenix Channels and LiveView as well.

 

WHY YOU SHOULD ATTEND THIS COURSE

  • Users have a higher expectation of the applications they use—real-time is a must in 2021 and beyond.
  • Real-time applications are easy to get started with but can have lots of nuance. Learn about the real-world challenges you’ll face when building your application.
  • LiveView has taken the Elixir world by fire—learn about the primitives that power it, so you can become the LiveView expert for your company

 

EXPERTISE

Intermediate

 

TARGET AUDIENCE

Professionals that are working with, or want to work with, real-time powered applications.

DURATION

1 day (8 hr with breaks)

 

PREREQUISITES

  • Familiarity with Elixir
  • We’ll build the entire set of knowledge needed from ground up, so honestly don’t need much more than Elixir

 

OBJECTIVES

  • Build a data pipeline based on GenStage / Broadway
  • Communicate multiple nodes over Phoenix PubSub
  • Ins and outs of Phoenix Channels / LiveView
  • Productionize a real-time application

 

COVERS THE FOLLOWING TOPICS

  • GenStage
  • PubSub
  • Channels / LiveView
  • Production deployments
  • Real-world experiences I’ve learned
  • Phoenix Tracker (Presence)

Secure Coding on the BEAM

02 Nov 2021
09:00 - 13:00
Aleksander Lisiecki

So you have mastered Elixir. Now the time has come to ask yourself a question: how secure is the code you are running? Do you know about BEAM potential vulnerabilities, the ways to attack it and how to defend against it? Join the Secure Coding in Elixir course to learn about Elixir good practices, which corners avoid and crush the BEAM in all sorts of funny ways.

 

EXPERTISE

Intermediate

 

COURSE DURATION

4 hours

 

TARGET AUDIENCE

Intermediate Erlang/Elixir developers, testers and devops working with BEAM projects

PREREQUISITES

  • Basic  Elixir syntax and concepts 
  • Basic familiarity with the BEAM

 

OBJECTIVES 

  • To learn about secure coding recommendations for programmers on the BEAM.
  • To be able to reduce vulnerabilities in projects and choose robust alternatives to dangerous functions.
  • To learn how to reduce the attack surface of a production environment.

 

COVERS THE FOLLOWING TOPICS

  • Protecting sensitive data
  • Sandboxing untrusted code
  • Preventing timing attacks
  • Applying OTP libraries (ssl, inets, crypto and others) to secure your code

The BEAM VM under the hood

08 Nov 2021
09:00 - 17:00
Dmytro Lytovchenko

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.

Putting the puzzle pieces together: Reliably ordering events in a distributed system

09 Nov 2021
09:00 - 17:00

Consensus is a trade-off in distributed systems, and one that's underutilized. Single leader systems are the default and we often fail to take advantage of the scale that can be achieved by relaxing the constraint of a single source of truth. We'll discuss some of the varying levels of consistency that can be selected by relaxing constraints, and their progressive advantages for scaling solutions and the detrimental effects this has on a global understanding of order. In the afternoon, we'll discuss CRDTs and the contribution they can make by leaving applications in a predictable, coherent state even with eventual consistency and how CRDTs can be leveraged to create practical systems with low consistency and high availability

 

EXPERTISE

Intermediate

 

TARGET AUDIENCE

Experienced Elixir developers who have some distributed systems background

 

DURATION

8 Hours

 

OBJECTIVES

  • Attendees should come away with an understanding of consistency models affect what we can say about the order of events in a distributed systems