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.
Past Activities
Code BEAM V America
09.15 - 14.45
Erlang for Beginners
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
- 3 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
Code BEAM V Europe
10.00 - 14.30
OTP for Erlang Programmers
OTP is the middleware, libraries and tools used to design and architect Erlang systems. The Basic OTP course covers the main principles, including process design patterns, supervisors, applications and release handling. It will give the participants the ability to develop and architect Erlang systems. Completion of the Basic or Compete Erlang courses are necessary to enroll in this intermediate course. Basic OTP can be complemented with the one day addons focusing on architecting Erlang systems and Erlang in operations.
EXPERTISE
- Intermediate
COURSE DURATION
- 5 days
TARGET AUDIENCE
- Software developers & engineers
PREREQUISITES
- Intermediate user of Erlang, preferably followed by three months of practical experience.
- Ideally you already know about about Erlang Term Storage, concurrent Erlang, error handling and maps and records
WHAT WILL THE ATTENDEE LEARN
- Understand the design principles of OTP
- Understand OTP behaviours
- Understand OTP system configuration
- Awareness of the available OTP applications
COVERS THE FOLLOWING TOPICS:
- Introduction
- Behaviours
- Generic Servers
- State Machines
- Supervisors
- Event Handlers
- Applications
- System Architecture Support Libraries
- System Principles
WHY YOU SHOULD ATTEND THIS COURSE
- Helps you get over the hurdle of efficiently learning how to build systems with OTP
- Allows you to avoid the pitfalls and borderline cases handled in its libraries
- A cost effective approach to increasing productivity whilst reducing mistakes
- Allows you to design and develop systems using the globally recognised Erlang approach
Code BEAM SF
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.
Code BEAM STO V
09.00 - 17.00
OTP for Erlang Programmers
OTP is the middleware, libraries and tools used to design and architect Erlang systems. The Basic OTP course covers the main principles, including process design patterns, supervisors, applications and release handling. It will give the participants the ability to develop and architect Erlang systems. Completion of the Basic or Compete Erlang courses are necessary to enroll in this intermediate course. Basic OTP can be complemented with the one day addons focusing on architecting Erlang systems and Erlang in operations.
EXPERTISE
- Intermediate
COURSE DURATION
- 5 days
TARGET AUDIENCE
- Software developers & engineers
PREREQUISITES
- Intermediate user of Erlang, preferably followed by three months of practical experience.
- Ideally you already know about about Erlang Term Storage, concurrent Erlang, error handling and maps and records
WHAT WILL THE ATTENDEE LEARN
- Understand the design principles of OTP
- Understand OTP behaviours
- Understand OTP system configuration
- Awareness of the available OTP applications
COVERS THE FOLLOWING TOPICS:
- Introduction
- Behaviours
- Generic Servers
- State Machines
- Supervisors
- Event Handlers
- Applications
- System Architecture Support Libraries
- System Principles
WHY YOU SHOULD ATTEND THIS COURSE
- Helps you get over the hurdle of efficiently learning how to build systems with OTP
- Allows you to avoid the pitfalls and borderline cases handled in its libraries
- A cost effective approach to increasing productivity whilst reducing mistakes
- Allows you to design and develop systems using the globally recognised Erlang approach
Code BEAM STO 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
Code BEAM STO 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
Code BEAM America 2021
10.30 - 10.55
Fireside chat on BEAM Languages with Erlang co-inventor Robert Virding
In this fireside chat, Mariano Guerra and Robert Virding, creators of many languages on the BEAM including Erlang(!!), Effene, LFE and LuErl will discuss past, present and future of languages on the BEAM, current and future challenges and opportunities. Join them, prepared with your own questions.
Code BEAM SF
09.05 - 09.50
BEAM on the edge - Innovation through problem solving
"BEAM on the Edge” explores designing innovative solutions under ambiguous circumstances. Robert Virding discusses how the core Erlang team took a different path from the rest of the software world in the design and reason of the BEAM itself. Frank Hunleth describes the burgeoning world of IoT, problems that the BEAM is well suited to solve, and now Nerves makes those solutions a reality. Frank Savage takes us to the world of functional GUI, why http isn’t appropriate to solve all problems and how Scenic uses the BEAM to explore solutions in this space.
Code BEAM V America
11.50 - 12.30
Fireside chat on LFE with Robert Virding and Duncan McGreggor
In this session we will seek Robert's advice on practical matters when creating applications and services in OTP on the BEAM, design decisions that face every implementor sooner or later, how creating software in LFE may or may not affect such decisions, and common misconceptions that must be overcome when building distributed solutions for customers. If time allows, we will take the opportunity to hear Robert's thoughts on best practices for BEAM language designers.
Code BEAM V America
09.05 - 10.05
History and philosophy of Erlang with its creators
Garrett Smith will host a fireside chat with Erlang co-inventors Mike Williams and Robert Virding, and the co-founder and former head of the Ericsson Computer Science Lab Bjarne Dacker. In his fireside, Garrett will be exploring the Erlang rationale, understanding how to drive innovation aimed at solving specific problems, and moving the results from a research institution to a commercial entity. As with previous fireside chats with Erlang-co inventors, expect lots of nuggets, anecdotes and stories explaining how, 30 years on, Erlang is still leading the way in the space of concurrency, distributed programming, resilience and scale.
Code BEAM STO V
14.20 - 15.00
Programming Languages on top of the BEAM
Talk about the implementation of languages on top of BEAM which have not the same semantics as Erlang so, it is not going to be a talk about languages like LFE or Elixir but also others like Lua or PHP which are implemented in an interpreted way. The talk is going to review the issues that can occur, solutions to them and also give some examples about how in the end they can be done.
Code BEAM STO V
16.45 - 17.25
Ask me anything about creating Erlang
Open meeting with Erlang Creators. Unmute yourself and ask the guest any question about his work you like.
Code BEAM STO V
17.00 - 17.40
Ask me anything about creating Erlang
Open meeting with Erlang Creators. Unmute yourself and ask the guest any question about his work you like.
Code Mesh LDN
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.
Code BEAM Europe 2022
09.05 - 09.50
Backtracking through Time and Space in Erlang
Erlang grew out of experiments in logic programming in the 80s, but very little of that heritage remains today. This talk revisits those early days to explore the ideas that were borrowed from Prolog, the ideas that were forgotten, and the ideas that we may yet revisit in the future.
We'll discuss the connections between the earliest implementations of Erlang and modern metaprogramming techniques, how Elixir's pipe operator relates to parsing, and what declarative programming can teach us about distributed shared memory. All of these ideas will come together in an exploration of how the BEAM ecosystem can leverage these techniques today to shape the way we might write code in the future!
Code Mesh LDN
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.
Code Mesh LDN
16.30 - 17.30