<

Robert Virding

Co-creator of Erlang, Trainer

Robert Virding 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.

Upcoming Activities

Robert Virding
Code BEAM SF
Training/ 02 Mar 2020
09.00 - 17.00

OTP for the seasoned Erlanger

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.

Robert Virding
Code BEAM SF

Keynote title TBC

TBC

Past Activities

Robert Virding
Code Mesh LDN
Tutorial/ 06 Nov 2019
09.00 - 12.30

Thinking concurrently

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.

Robert Virding
Code BEAM STO 2019
Training/ 13 May 2019
09.00 - 17.00

KUNG FU ERLANG: from zero to hero

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
Robert Virding
Code Mesh LDN
Tutorial/ 06 Nov 2019
13.30 - 17.00

OTP: middleware for concurrent, distributed, scalable architectures

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.

Robert Virding
Code BEAM STO 2019
Training/ 20 May 2019
09.00 - 17.00

OTP for the seasoned Erlanger

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
Robert Virding
Code BEAM STO 2018
Training/ 04 Jun 2018
08.00 - 18.00

ADVANCED ERLANG TECHNIQUES

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).
Sam Aaron / Jeremy Ruston / Robert Virding
Code Mesh LDN
08 Nov 2019
16.30 - 17.30

TBD: be inquisitive, share and inspire

In many conversations and talks given after the late Joe Armstrong retired, he rarely talked about Erlang, and instead focused on the different expressions of the ideas that had driven it: models of concurrency based on the realities of physics, the importance of self contained code and applications, and perhaps most important of all, the importance of designing by prototyping.

For this special keynote, one of Erlang’s co-inventors and the creators of Sonic Pi and TiddlyWiki reflect on what they have learned while collaborating with Joe.

Robert Virding
Code BEAM STO 2018
31 May 2018
17.15 - 17.40

Implementing Languages on the BEAM

This talk will breifly look at the problem of implementing languages on top of the Erlang system. It will briefly describe the properties of the BEAM and how how they affect languages running on top of it. We will describe three different ways of "adding" languages to the BEAM and Erlang/OTP system and the different properties they have.

@Code BEAM STO 2018

Robert Virding / Mariano Guerra
Code BEAM SF 2018
15 Mar 2018
11.35 - 12.20

Implementing Languages on the BEAM

Why LFE is not just Common Lisp on the BEAM, why Elixir is not just Ruby, why Efene is not just Python?

In this talk we will explore the ressons why BEAM languages are the way they are, which things the BEAM makes easy and which makes... complicated.

We will explore what's involved in developing a language on the BEAM that's actually useful and share experiences and tips.

@Code BEAM SF 2018