Training:

Haskell from Zero to Hero

04 Nov 2020
08:00 - 11:30
John Hughes

Haskell is your gateway to functional programming. Learning it will make you a better programmer regardless of what language you use, and using it will guarantee you ship much less code. From one of the co-creators of Haskell, this tutorial will act as a soft introduction to the language, flattening out the learning curve and speeding up the process. 

 

EXPERTISE

Intermediate

 

COURSE DURATION

3 hours 30 minutes

 

TARGET AUDIENCE

Software developers

PREREQUISITES

  • Good programming skills in at least another programming language
  • Familiarity with imperative or OO paradigms
     

OBJECTIVES 

  • Reduce the barrier to entry to Haskell through the basics
  • Appreciate the abstractions of Functional Programming
  • Get a solid understanding of the type system and other language construcs

 

COVERS THE FOLLOWING TOPICS

  • Functions, Lists and Lists Comprehensions
  • Types and Typeclasses
  • Pattern Matching and its uses
  • Recursion, Higher Order Functions and Lazy Evaluations
  • I/O & Modules

 

Haskell is not a hard language to learn. What is hard is unlearning the bad habits you have picked up. This tutorial aims at giving you a birds-eye view of the foundations, explaining the rationale behind the design decisions. In doing so, it will make it easier for you to use the concepts and ideas in your daily work, even if it is not with a functional language. 

Highlights and Insights in Distributed Programming

04 Nov 2020
13:00 - 16:30
Peter Van Roy
New York 8.00AM, Paris 14.00PM

There are three certainties in life, death, taxes, and node failures in distributed systems.  This tutorial will explain some useful but less understood concepts and techniques for designing distributed systems.  The tutorial is not intended to be exhaustive but to improve your knowledge and be entertaining.  I will first go over some of the basic concepts and explain what they are all about.  Then I will present several important problems: replicated data structures, laws of large systems, how to use failure, and self management.  Example systems will be taken from projects that I have worked in.  Prerequisite for this tutorial is some modest experience with concurrent and distributed programming, in particular experience with Erlang will help you get the most from this tutorial.

 

EXPERTISE

Intermediate

 

COURSE DURATION

3h30 minutes

  • Basic concepts.  We will present partially synchronous systems, the Internet, and eventually perfect failure detectors.  These concepts are ubiquitous but are not always well understood.  We will explain causality and when to use it and not use it.  We will talk about time-outs inside large systems and how to use them correctly.
  • Replicated data structures.  An important distributed pattern is the consistent replicated data structure.  We will talk about two important techniques for implementing such: the RSM (Replicated State Machine), which uses consensus to achieve consistency, and the CRDT (Conflict-free Replicated Data Type), which uses clever mathematics to achieve consistency without needing consensus.  As part of the presentation on CRDTs, we will explain different kinds of consistency, including eventual consistency and convergent consistency, and when they are useful.
  • Laws of large systems.  Large system design is a general discipline that is especially useful for distributed systems.  We will talk about the CAP theorem and how to use it as a system design tool.  We will talk about Buridan’s theorem and its consequences for big systems.  We will talk about the induction fallacy, where relying on induction gives exactly the opposite effect to the desired result.  We will introduce our good friend Dijkstra’s demon.  We will present the next exponential wave, Internet of Things, and give some ideas on how to ride it.
  • Failure is good.  Failure is very familiar to Erlang programmers.  Failure is quite normal, and is even good.  In large systems, if there are thousands of nodes, then there will always be failures.  We will explain how to build systems that survive and even thrive (improve) with failures.  Failures allow to continually renew the system, which is an approach that has been used by biological systems since the beginning of life on Earth, and which is especially useful in distributed systems.  We will present software rejuvenation as one technique that takes advantage of failure.
  • Self management.  Large systems must be able to manage themselves.  We will talk about the two basic approaches to self management, namely control-oriented autonomic computing and data-oriented autonomic computing.  We will give a general approach for control autonomy called WIFS (weakly interacting feedback structures).  We will give a general approach for data autonomy called LiRA (LightKone Reference Architecture) and its two data management principles.  Both data and control autonomy are important; different parts of a large system may use one or the other or both together.  We will also present hybrid gossip, which is a sweet spot that combines the advantage of classical distributed algorithms (efficiency) with the advantage of gossip algorithms (resilience).

Introduction to TLA+

05 Nov 2020
16:00 - 19:30
Annette Bieniusa
New York 11.00AM, San Francisco 8.00AM

Concurrent and distributed programs are notoriously difficult to get right. Even tiny variations of algorithms like Peterson’s lock for mutual exclusion lead to significantly different behaviours and errors that are complex to locate.

TLA+ is a high-level language for modelling such programs and specifying their behaviour in a rigorous way. In this tutorial, you will learn how to write concurrent and distributed algorithms in PlusCal, a pseudo-code like interface for TLA+, and how to specify correctness conditions using temporal logic. We will further apply the model-checker TLC and discuss typical pitfalls when working with TLA+.
 

 

EXPERTISE

Level required to take the course 

 

COURSE DURATION

2h 30 minutes

 

PREREQUISITES

Please install the TLA Toolbox on your machine by following the instructions on this page.

Architecting Reactive Systems for Scalability and Availability

05 Nov 2020
20:00 - 23:30
Francesco Cesarini
San Francisco 12.00PM, New York 15.00PM

Learn how to architect 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 the Erlang ecosystem, Elixir included, but are in fact technology agnostic and could be applied to most stacks, including Scala/AKKA, .net and others.

It has to be event driven and react to external stimulus, load, and failure. It must always be responsive. You have heard many success stories that suggest Erlang is the right tool for the job. And indeed it is—but while Erlang is a powerful programming language, on its own, it’s not enough to group these features together and build complex reactive systems. To get the job done correctly, quickly, and efficiently, you also need middleware, reusable libraries, tools, design principles, and a programming model that tells you how to architect and distribute your system.

 

EXPERTISE

Intermediate

 

TARGET AUDIENCE

Software Developers and architects

 

DURATION

3,5 hours

 

PREREQUISITES

Software development experience is a must, as is the understanding of data consistency models. Experience or exposure to designing and architecting systems is a benefit, but not a prerequisite.

OBJECTIVES

We will focus on:

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.

Observability: 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.

Functional Software Architecture

06 Nov 2020
13:00 - 16:30
Michael Sperber
New York 8.00AM, Paris 14.00PM

The last 10 years have seen a boom of functional-programming adoption for sizeable industrial projects. This is despite the fact that precious little has been written about the architecture of large functional programs. Many architectural styles and techniques common in the Enterprise world can’t be applied directly when using functional programming, or require significant changes. On the other hand, the benefits on architecture from using functional programming are significant: Design methodologies like Domain-Driven Design can be adapted to using functional programming, and then extended using combinator models and denotational design. The tutorial gives an overview of design and architecture techniques available to the functional software architect.

 

EXPERTISE

 Basic software development experience

 

COURSE DURATION

3,5 hours

 

TARGET AUDIENCE

Software architects, developers

 

PREREQUISITES

Basic programming skills in a functional language.

 

OBJECTIVES 

  • understand architectural aspects of functional programming
  • know fundamentally functional modelling techniques
  • know where traditional architecture and functional architecture connect

 

 COVERS THE FOLLOWING TOPICS

We'll pick 2-4 of the following topics, based on audience preference:

  • functional architecture overview
  • introduction to Haskell, Clojure, F#, Racket, Elixir, Scala, Erlang
  • controlled effects
  • combinator models
  • embedded DSLs
  • monads for the working programmer
  •  property-based testing
  •  DDD vs. FP
  • "I'll never convince my boss to use this."
  •  Denotational Domain-Driven Design
  •  Programming the Day after Tomorrow: Dependent Types

 

 WHY YOU SHOULD ATTEND THIS COURSE

  • Know functional programming, but are unsure how to do an entire functional application
  • Know DDD and functional programming, would like to connect the two
  • Want to get effects under control