Training:

Distributed Live Tracing Tutorial

28 May 2020
09:00 - 13:00
Radosław Szymczyszyn

Gabor Olah will show you how to use a unique feature of the Erlang VM: Tracing Erlang and Elixir programs in a distributed network. Tracing allows us to understand a running system from the perspective of the VM. We will discover how to utilise this feature to x-ray everything from a single node to a distributed application. We will discuss how to incorporate tracing into a development workflow as well as safe tracing in production. We also explore other possibilities of debugging of the BEAM. We will demonstrate the techniques for both Erlang and Elixir.

---

Expertise: Intermediate

Target audience: Software Developers & Support Engineers

Duration: 4 hours

Prerequisites: Practical experience of Erlang or Elixir

Objectives:

  • Understanding of the low level mechanism of tracing
  • Understanding of where tracing fits into the development flow
  • Understanding tracing in a single noe
  • Understanding tracing in a distributed cluster

Course Outline

The course covers the topics of tracing in the BEAM virtual machine. It is applicable for both Erlang and Elixir as most libraries are the same. The course covers the following tracing libraries:

  • Built-in tracer
  • dbg
  • redbug/rexbug

The course gives practical advice for tracing on a live system let it be a single node or a distributed cluster. We will discuss how tracing can complement logging and monitoring.

ABOUT THE TRAINER

Radek Szymczyszyn been programming since he was 15 and doesn’t intend to stop. For the last 9 years he’s been working professionally with BEAM technologies, both remotely and on-site, assisting companies from startups to telecommunication giants build and scale their systems. His main tools are Erlang and XMPP, and he’s quite keen on making the Erlang ecosystem a good place to be in, by participating in the Erlang Ecosystem Foundation Documentation WG.

Elixir Programming Training for Beginners

18-20 May 2020
09:00 - 18:00
Robert Virding

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. 

Architecting Reactive Systems for Scalability and Availability

28 May 2020
09:00 - 13:00
Francesco Cesarini

Learn how to implement 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 Erlang, but are in fact technology agnostic and could be applied to most stacks, including Scala/Akka, Elixir/OTP and others.

Expertise 

  • Intermediate

Target audience 

  • Software Developers

Duration

  • 4 hours

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

Trainer

Francesco Cesarini is the founder of Erlang Solutions Ltd. He has used Erlang on a daily basis since 1995, starting as an intern at Ericsson’s computer science laboratory, the birthplace of Erlang. He moved on to Ericsson’s Erlang training and consulting arm working on the first release of OTP, applying it to turnkey solutions and flagship telecom applications. In 1999, soon after Erlang was released as open source, he founded Erlang Solutions, who have become the world leaders in Erlang based consulting, contracting, training and systems development. Francesco has worked in major Erlang based projects both within and outside Ericsson, and as Technical Director, has led the development and consulting teams at Erlang Solutions. He is also the co-author of 'Erlang Programming' and 'Designing for Scalability with Erlang/OTP' both published by O'Reilly and lectures at Oxford University.

The Beam VM Under the Hood

27 May 2020
09:00 - 17:00
Michał Ślaski

Everything you wanted to know about the BEAM but were afraid to ask - now ONLINE from the comfort of your home!

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.

Obejctives

  • Understand how the BEAM works under the hood.

Prerequisites 

  • Experience in developing and supporting languages running on the Beam, including Erlang and Elixir.
  • Fine-tune it and optimize its settings for throughput and memory use.

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 - highlights of the BEAM Virtual Machine, the features which make it stand out in comparison to other VMs.

Processes under the hood - how memory is allocated, managed and garbage collected.

The Process Scheduler - how the schedulers work, how it scales on multi-core architectures and what its limitations are.

Memory Management - different memory types including system, atom, binary, code and ets tables.

Tweaking and fine-tuning - tweaks and possible fine-tuning

 

Trainer 

Michal Slaski - AGH graduate, Erlang programmer since 2005. In 2014 began organizing the Lambda Days conference, which focuses on functional languages and new trends in computer science. In the same year also started organizing programming workshops for people who would like to learn languages such as Erlang, Elixir or Swift. Currently a Technical Lead in Erlang Solutions and frequent conference speaker.