Training:

Architecting Reactive Systems

08 Mar 2021
09:30 - 17: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.

 

EXPERTISE

Intermediate

TARGET AUDIENCE

Software Developers and architects

DURATION

3 hours 30 minutes 

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

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

Shipping Greenfield Elixir in a Legacy World

09 Mar 2021
09:00 - 17:00
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.

Erlang for Beginners

02-04 Mar 2021
09:15 - 14:45
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

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