<

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 conferences:

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.

 

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 Lite Budapest
Training/ 17 Sep 2019
09.00 - 17.00

Complete OTP

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 intermediate software developers and engineers.

 

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
  • Building Compliant Processes
  • System Principles

Past conferences

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