Erlang Express - March 7-9
Target Audience: Software Developers
Trainer: Joe Armstrong
Prerequisites: Good programming skills in another language
Objectives:
• Understanding of the basics of Erlang.
• Read/Write/Design Erlang Programs.
• Good knowledge of the development environment and tools.
• Provides basics needed to attend the Advanced Erlang/OTP course
Duration: Three days
Registration: 08:30 on 7 March 2016
Venue: Marines' Memorial Club and Hotel
Description: The course contains all the Erlang basics such as sequential and concurrent programming, along side error handling. The Erlang development environment is presented, with a special emphasis on the Erlang mode for Emacs alongside the major debugging tools. Good and bad programming practices are discussed, as are tools used to profile the system. OTP design principles and concepts are sneaked into the material as well as the exercises.
Course Contents:
Introduction
Introduction to the software needs of telecom control systems, followed by a history of Erlang, its features, and product and research examples within and outside Ericsson.
Basic Erlang
This section deals with Erlang data types and pattern matching. Functions, modules, and BIFs are discussed. Before the exercises, the Erlang shell, useful shell commands as well as Emacs and its Erlang mode are introduced.
Sequential Programming
The Sequential Programming section comprehends conditional evaluations, guards and scope of variables. It then introduces recursion, with a special emphasis on different recursive patterns, tail recursion, and space saving optimizations. Before the exercises, libraries and their manual pages, possible run time errors and the debugger are demonstrated.
Concurrent Programming
This section describes the creation of processes and their life span. It looks at sending and receiving messages, selective reception, and passing data in the messages. It continues with the various uses of time outs and registering processes, and terminates by showing the generic process code structure. Before the exercises, a demonstration of the Process Manager tool is given.
Process Design Patterns
This section introduces the concept of process patterns, preparing the students for the OTP behaviours. It gives a detailed example of a client server system, looks at finite state machines and event handlers. Synchronous versus asynchronous message passing is discussed.
Process Error Handling
This section introduces the simple but powerful error handling mechanisms in processes. It looks at process links, exit signals and their propagation semantics. How robust systems are built in Erlang are discussed, and an example from the Process Design Patterns section is re-implemented, making it robust.
Code Updating
The section introduces software upgrade during run time. The error handler, the code server, and code search paths are covered, as is the .erlang file.
ETS tables
An introduction to the Erlang Term Storage is given, together with its different table options. Examples on when to use and not to use ETS tables are covered. A demonstration of the table visualizer is provided.
Distributed Programming
An introduction to the requirements of distributed systems is given, and how Erlang is able to fill these requirements. The distribution syntax and semantics are covered, followed by the BIFs and the net kernel.
Ports and Sockets
An introduction of the mechanisms used to make Erlang more open are taken up in this section. Ports, for external communication within the same machine, and Sockets, for communication on IP networks are discussed. The difference between TCP and UDP is described.
Advanced Erlang Techniques - March 7-9
Trainer: Marc Sugiyama
Target Audience: Software Developers, Support & Test Engineers with experience in Erlang,
Prerequisites: Knowledge and experience of Erlang, at least equivalent to Erlang by Example or Erlang Express courses. Knowledge of OTP is beneficial but not strictly necessary. Experience with building and maintaining large systems.
Objectives: Understand how to use more expert tools for building and testing systems. Understand the basics of profiling and debugging of running systems.
Duration: Three days
Registration: 08:30 on 7 March 2016
Venue: Marines' Memorial Club and Hotel
Course Contents:
This three-day course presents some more advanced tools for building 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 Common Test testing environment is also described with examples of how to build testing environments from the very simplest upto complex environments for testing distributed systems. There are exercises for all the sections in this course.
Types and Checking
While Erlang is dynamically typed it is practical to be able to document the types of functions in a consistent way. In this section we present the standard way of specifying function types. We also present two very useful tools, dialyzer and typer, which are used to type check applications.
Parse Transforms
There are many occaisions when it is useful to be able to generate code at compile time. The standard OTP system as well as commonly used libraries do this. This section covers parse transforms, the standard Erlamg compiler interface for this, as well as some tools which are useful together with parse transforms.
Common Test
A guide on how to use Common Test, from unit tests to large scale testing. This covers unit test, testing with state, test groups and suites, how to configure tests, write specifications and do distributed testing.
Profiling
The standard Erlang release contains a number profiling tools. This sections looks at these and shows they can be used to profile systems to gain a deeper understanding of their behaviour.
Trace Bifs and Match Specifications
Trace bifs provide a low-level trace mechanism which can be used without trace compiling the code. It allows tracing garbage collection, memory consumption, message passing, and other process activities including local and global function calls. This section looks at how to activate and deactivate the different trace flags as well as turning them on for different processes, modules and functions. It also covers match specifications, a low level mechanism which match and test the arguments passed to traced function calls.
The dbg tool
The dbg tool is a text based debugger providing a friendly interface to the trace bifs. This section introduces the tool and covers how this tool can be used in a distributed environment or how the output can be redirected on other nodes, log files, ports and sockets.
Trainer: Thomas Arts
Duration: Three days. This training course can also be purchased as a 1-day or a 2-day option. Please email conferences@erlang-solutions.com for details.
Requirements: Basic knowledge of Erlang.
Registration: 8:30 on 7 March 2016.
Venue: Marines' Memorial Club and Hotel in Union Square.
Description:
QuickCheck is a tool that let you specify what your software should do and then generates hundreds of meaningful test cases that explore that property. Almost always it finds a test case that the developer has not thought of. Properties are much easier to maintain than individual test cases and cover your subject under test better. In telecommunication and the automotive industry, this test method is used on large scale…. learn how to do it yourself in this course. Write properties in Erlang and have QuickCheck do your testing.
In the first day, we cover properties and generators and all we teach in that day can be used with QuickCheck Mini, the free QuickCheck version.
OTP Express - March 14-16
Trainer: Francesco Cesarini
Target Audience: This course is aimed at experienced Erlang Software Developers and Designers who need to understand Behaviours.
Prerequisites: Existing experience using Sequential and Concurrent Programming with Erlang on projects.
Objectives:
• Use existing Design Patterns supported by Erlang and OTP.
• Apply Generic Behaviours, Finite State Machines and Event handler Patterns.
• Use the Supervisor and Applicaton Behaviours Patterns.
• Write your own Design Patterns.
• Structure large Erlang based systems.
Goal: Design fault-tolerant systems.
Duration: Three days
Registration: 08:30 on 14 March 2016
Venue: Marines' Memorial Club and Hotel
Description:
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.
Introduction
This section introduces the need and advantages of using middleware in the developmentof 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 section.
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.
Special 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 explains 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.
Duration: Three days
Registration: 08:30 on 14 March 2016
Venue: Marines' Memorial Club and Hotel
Kazoo March 14-16
Trainer: James Aimonetti
Target Audience: Developers and Ops
Prerequisites:
The focus will be on leveraging Kazoo to build applications; as such, we won't focus too heavily on teaching Erlang. Please come with some experience using Erlang, exposure to OTP principles and patterns, and preferably having used some of the more popular Erlang libraries (lager, Cowboy, poolboy, etc). General telephony/VoIP experience welcome but not required. Basic Linux sysadmin experience as well.
Objectives:
The participant will get an intro to the Kazoo code base and how to build applications, leveraging existing libraries and subsystems included in the platform.
Duration: Three days.
Registration: 8:30 on 14 March 2016.
Venue: Marines' Memorial Club and Hotel in Union Square.
Description: Want to learn how to write applications for the most flexible, scalable, and advanced telephony platform, Kazoo? This three-day, hands-on course will take you through the platform, starting with the libraries, utilities, behaviors, and patterns developed over the last three years to get you going on the right track. From there, we'll journey into the existing applications so you can see design decisions that worked, that didn't worked, and the tradeoffs to consider when you take the reigns to build your own application.
The course will cover topics such as using the AMQP behavior, gen_listener, to consume messages off the AMQP bus; using the BigCouch utilities to query, create, and delete databases, documents, and views; basic Erlang application structure to build new Kazoo applications; and so much more!
We will have a variety of fun "toy" applications you can choose from for the final project, but if you have ideas for your own application, we encourage you to bring those ideas and see if you can get a prototype together before you leave.