Training:

Haskell from Zero to Hero

04 Nov 2020
08:30 - 12:00
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. 

Microservices Architecture with RabbitMQ

04 Nov 2020
09:30 - 12:00
Ayanda Dube

RabbitMQ is a well proven and popular messaging platform for building fast, efficient Microservice based systems which interact using the Advanced Message Queuing Protocol (AMQP). In this tutorial, I teach you how to design and implement a Microservices Based System Architecture using RabbitM. We build a complete Microservice based system from the ground up, define it's communication primitives over RabbitMQ, do some coding, deploy it on Docker and take it for a test run, all in 1-day! Join us!

 

EXPERTISE

Junior, Intermediate, Senior

 

COURSE DURATION

1-day

 

TARGET AUDIENCE

Software Developers/Engineers/Architects

PREREQUISITES

Experience in at least 1 Programming language of choice

 

OBJECTIVES 

Understand AMQP Messaging Design Principles

  • Understand Designing Microservices 
  • Understand Microservices/Inter-application Communication Principles
  • Understand Asynchronous Messaging Principles Implementing Microservices
  • Understand how to scale Microservices with RabbitMQ

 

COVERS THE FOLLOWING TOPICS

  • AMQP
  • RabbitMQ
  • Microservices Design Principles
  • Asynchronous Messaging Patterns
  • Load Balancing
  • Deployment
  • Scaling
  • Operations and Maintenance

Welcome to Prolog

04 Nov 2020
08:30 - 12:00
Anne Ogborn

As machine learning matures, it is becoming obvious that we need explainable solutions. As functional programming matures it becomes obvious that we need inference and nondeterminism. And linked open data demands reasoning. This half-day workshop will introduce the logic programming paradigm, in which programs are expressed as a set of logical rules and executed by finding proofs of queries.
 

EXPERTISE

Beginners

 

COURSE DURATION

3 hours 30 minutes

 

TARGET AUDIENCE

Programmers who want to be able to reason with their computer

 

PREREQUISITES

Basic computer skills. Previous experience programming is unfortunate, but we'll help you get over it.

OBJECTIVES 

Students should come away with an appreciation of how Prolog is different (and better!) and equipped to become fully competent in the language by independent study.

 

COVERS THE FOLLOWING TOPICS

SWI-Prolog is the most highly developed and widely used implementation of Prolog.

Prolog has been in continuous use in academic research settings since it's invention in 1972, provides unparalleled power. Many problems which would be difficult to express in other languages are simple in SWI-Prolog. SWI-Prolog is a 'batteries included' modern language, ready for real world tasks like web development and process control.

In this dynamic hands on workshop we'll learn the basics of SWI-Prolog, and look at some of the amazing things it can do.

 

WHY YOU SHOULD ATTEND THIS COURSE

  • e.g. Helps you get over the hurdle of efficiently understanding the concepts behind Elixir
  • Gets you thinking concurrently about your application

Introduction to Elixir

04 Nov 2020
08:30 - 12:00
Mikael Muszynski

This hands on tutorial provides an introduction to functional and concurrent programming paradigms in Elixir. Attendees will learn about the tool chains, the top-down development approach and rationale, helping jumpstart their foray into an emerging programming language used by startups and enterprise. 
 

EXPERTISE

Beginners

 

COURSE DURATION

3 hours 30 minutes

 

TARGET AUDIENCE

Developers

PREREQUISITES

  • Good programming skills in another language
  • Familiarity with top down development approaches

 

OBJECTIVES 

  • Learn how to structure a program in Elixir
  • Understand Elixir’s concurrency model for scale
  • Understand Error handling principles for resilience

 

COVERS THE FOLLOWING TOPICS

  • Sequential Elixir & Functional constructs
  • Concurrent Elixir
  • Error handling mechanisms
  • Tooling and program structures

 

WHY YOU SHOULD ATTEND THIS COURSE

This tutorial helps you get over the hurdle of efficiently understanding the concepts behind Elixir, allowing you to use the full power of the Erlang ecosystem using a familiar tool chain and development approach.  It will get you thinking concurrently about your application, and explain how to use this concurrency to design for scale and resilience.

Getting Better at Reading Code

04 Nov 2020
13:00 - 16:30
Felienne Hermans

The aim of the workshop is to teach techniques that can be applied to any piece of code and the exercises are designed to be carried out in sequence on a single piece of between 80-180 lines; the idea being that practice of reading and analysing these short bits of code together makes programmers more fluent readers in their day to day. To give an idea of how the techniques work on understanding API vs. understanding part of an application, each group will get one session with library code and one with application code.

In this hands-on workshop, participants can experience the benefits of a focus on reading code, including better code review techniques, insight into the perspectives of others by taking the time to understand their code, impetus to write ‘readable’ code, improved ability to scan and understand unfamiliar code and appreciation of the insights that can be gained by reading code together. 

EXPERTISE

Any level

 

COURSE DURATION

Half-day

 

TARGET AUDIENCE

Everyone who wants to get better at reading code

 

PREREQUISITES

Helpful to have a printer or a tablet to be able to write on code.

 

OBJECTIVES 

  • How to read code and why that matters
  • Concrete exercises to practice reading code
  • Tips and techniques for running a code reading club at their own org.

An Introduction to Functional Programming in Go

04 Nov 2020
13:00 - 16:30
Eleanor McHugh

Join Eleanor McHugh in a relaxed workshop setting to explore functions in Go both as a mathematical abstraction and as useful little machines for getting stuff done. There'll be a couple of simple problems to illustrate the ideas we’ll be covering, plenty of code you can study later, and a few thought-provoking examples which may permanently change the way you think about Go and about coding.

 

EXPERTISE

Intermediate

 

COURSE DURATION

Half day

 

TARGET AUDIENCE

  • Anyone with an interest in learning Go. 
  • Anyone who already knows Go and would like to explore functional programming. 
  • Anyone who likes closures.

 

PREREQUISITES

It will be helpful (though not necessary) to install Go and read the basic docs at http://golang.org/

WHY YOU SHOULD ATTEND THIS COURSE

Every coder thinks they know functions. Neat little packages of code for hiding away all that ugly implementation detail we only want to write once and would prefer no one else ever saw. In fact we take them so much for granted that when academics wax lyrical about their amazing potential we tend to assume they’re talking about the very same thing and wonder what all the fuss is about. Especially when presented with languages like Haskell which read more like a maths textbook and come with that knowing smile our parents had when telling us to eat our green vegetables: this is better for you.

They’re essentially saying our functions aren’t proper functions. That we’ve embellished them with junk we don’t need and that by using a pure functional language we’ll build healthier programs.

But what if I were to tell you that for all it’s practical engineering bias Go has a pretty robust concept of what a function is and how it can be used that means we can steal insights from the academic world? That we can choose to be functional programmers when we want to and - heresy of heresies - use other paradigms when they make more sense for the problem at hand?

Join the half-day tutorial to find out the answer!

 

Highlights and Insights in Distributed Programming

04 Nov 2020
13:00 - 16:30
Peter Van Roy

There are three certainties in life, taxes, death and network issues. In his tutorial, distributed systems pioneer Peter van Roy will give you the fundamentals of how to overcome these issues by explaining

classics such as the CAP theorem, but also items that are less understood like eventual consistency and timeouts (timeouts are actually very badly understood!).  He will explain some of the fallacies in system design (like using induction) and how to overcome them.  Feedback in distributed systems programming is necessary, so Peter will explain how to do it.

Expect lots more in the same vein, explaining important and often misunderstood concepts and showing how to apply them.

 

EXPERTISE

Intermediate

 

COURSE DURATION

3h30 minutes

TARGET AUDIENCE

Developers and Architects who need an understanding of how to design and develop distributed systems.

 

PREREQUISITES

Knowledge of programming and concurrency models 

 

OBJECTIVES 

Gain an understanding and appreciation of the challenges involved in building distributed systems.

 

 COVERS THE FOLLOWING TOPICS

  • CAP theorem
  • Eventual consistency models 
  • Timeouts
  • Retry strategies
  • Fallacies in system design and how to overcome them

Introduction to TLA+

05 Nov 2020
16:00 - 19:30
Annette Bieniusa

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.

An Introduction to Idris 2

05 Nov 2020
16:00 - 19:30
Edwin Brady

Idris (https://idris-lang.org) is a functional programming language with first-class types. It encourages “type-driven development”, where we begin by giving a type and an empty function definition, and refine the definition – with the machine’s help – to a complete working program. This tutorial will introduce a new implementation - Idris 2 – and show how its new features facilitate the correct implementation of complex protocols (e.g. of the sort found in communicating concurrent systems). Assuming some background in typed functional programming, I will introduce type-driven development, show how to use types to captures functional properties of programs, and show how to use linear types to implement safe concurrent communication protocols.

 

EXPERTISE

Intermediate functional programmer

 

COURSE DURATION

Half day

 

TARGET AUDIENCE

Programmers with some experience of a typed functional language (e.g. ML, Haskell)

PREREQUISITES

  • Some basic knowledge about types: function types, polymorphic types, algebraic data types
  • Programming with recursive functions
  • Understanding of higher order functions

 

OBJECTIVES 

  • Understand foundations of functional programming with first-class types
  • Be able to formally reasoning about program properties
  • Represent protocols in types

 

COVERS THE FOLLOWING TOPICS

  • Types as first-class constructs (dependent types)
  • Program synthesis via types
  • Quantities: erasure and linearity
  • Equality proofs
  • Protocols via linearity

 

 WHY YOU SHOULD ATTEND THIS COURSE

  • It will teach you how to use types to structure programming, not only in Idris but in other typed languages
  • It will show you what is possible in a modern programming language with an advanced type system

Architecting Reactive Systems for Scalability and Availability

05 Nov 2020
20:00 - 23:30
Francesco Cesarini

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.

Multi-core Programing with Erlang

05 Nov 2020
20:00 - 23:30
Robert Virding

Erlang and Elixir have a concurrency oriented programming model which, thanks to its no shared memory and message passing, scales on multi-core architectures. In this tutorial, we will explore this concurrency model, demonstrate how it scales on multi-core architectures and highlight the pitfalls and bottlenecks you will encounter. 


EXPERTISE

Intermediate

 

COURSE DURATION

3h 30 minutes

 

TARGET AUDIENCE

Developers

 

PREREQUISITES

Good programming skills in at least another programming language

OBJECTIVES 

  • Understand the difference between concurrent and parallel programming
  • Learn how to use programming models which scale on multi-core architectures 
  • Understand the basics of the Erlang concurrency and distribution models
  • Understand what is required to make a program (written in any language) scale vertically and horizontally

 

COVERS THE FOLLOWING TOPICS

  • A brief introduction to sequential and concurrent programming in Erlang
  • The distributed programming semantics of the Erlang Ecosystem
  • Amdahl's law
  • Multi-core and distributed programming in Erlang 

 

Moore’s law has changed. We don’t get the same increase in clock frequency as we used to. Instead, we get more cores. Erlang’s basic features, rooted in the actor model with no shared memory, are a perfect match for cloud environments. The complexity of multi-core programming and heterogeneous multi-core architectures are hidden from the developers, allowing them to focus on the program as if it was running on a single core. In this tutorial, Erlang co-inventor Robert Virding will introduce Erlang and its actor model, describe the challenges of multi-core programming and explain how this approach is positioning itself to win the multi-core challenge. Come and learn about the approach, so you can use it in your day to day work.

An Introduction to Functional Programming in Go

05 Nov 2020
20:00 - 23:30
Eleanor McHugh

Join Eleanor McHugh in a relaxed workshop setting to explore functions in Go both as a mathematical abstraction and as useful little machines for getting stuff done. There'll be a couple of simple problems to illustrate the ideas we’ll be covering, plenty of code you can study later, and a few thought-provoking examples which may permanently change the way you think about Go and about coding.

 

EXPERTISE

Intermediate

 

COURSE DURATION

Half day

 

TARGET AUDIENCE

  • Anyone with an interest in learning Go. 
  • Anyone who already knows Go and would like to explore functional programming. 
  • Anyone who likes closures.

 

PREREQUISITES

It will be helpful (though not necessary) to install Go and read the basic docs at http://golang.org/

WHY YOU SHOULD ATTEND THIS COURSE

Every coder thinks they know functions. Neat little packages of code for hiding away all that ugly implementation detail we only want to write once and would prefer no one else ever saw. In fact we take them so much for granted that when academics wax lyrical about their amazing potential we tend to assume they’re talking about the very same thing and wonder what all the fuss is about. Especially when presented with languages like Haskell which read more like a maths textbook and come with that knowing smile our parents had when telling us to eat our green vegetables: this is better for you.

They’re essentially saying our functions aren’t proper functions. That we’ve embellished them with junk we don’t need and that by using a pure functional language we’ll build healthier programs.

But what if I were to tell you that for all it’s practical engineering bias Go has a pretty robust concept of what a function is and how it can be used that means we can steal insights from the academic world? That we can choose to be functional programmers when we want to and - heresy of heresies - use other paradigms when they make more sense for the problem at hand?

Join the half-day tutorial to find out the answer!

 

Introduction to live coding music with Sonic Pi

05 Nov 2020
16:00 - 19:30
Sam Aaron

Live Coding systems encourage us to think extremely differently about programming languages and take ideas such as those found in reactive programming to the next level. For example, in addition to considering standard requirements such as reliability, efficiency and correctness we are also forced to deal with issues such as hotswapping, concurrency, determinism and time.

What is it like to think fluently with such concepts?

How might these ideas apply and benefit your development practices?

The object of this highly interactive workshop is not to just cover these questions but give you your own initial experiences to draw from. Together, we'll learn how to work with all these important concepts using Sonic Pi - whilst having a lot of productive fun.

Together we'll learn the basics of live coding through time using music as our guiding metaphor. However, we'll continually explore which domains other than music where live interaction and manipulation of running processes is both relevant and important.

 

Course contents

  • liveness
  • concurrency
  • coordination
  • determinism
  • time
  • hotswapping code

 

OBJECTIVES

To get hands-on experience of the basics of live coding and concurrency whilst also learning how to make crazy sounds and beats.

 

PREREQUISITES

Please come along with some headphones and a laptop with Sonic Pi pre-installed. You can get Sonic Pi from here.

 

Reviving Truth-Maintenance Systems

05 Nov 2020
16:00 - 23:00
Nada Amin and William Byrd

A truth-maintenance system is a reasoning system that makes assumptions and revises beliefs. It can be used as a sub-component in an expert system. This workshop will provide an overview of truth-maintenance systems, their implementation and application.  Attendees will implement their own truth-maintenance system in the language of their choice, based on a micro version in Racket/Scheme. The applications will encompass expert systems, dialectical models and epistemic logic.

 

EXPERTISE

Advanced users

 

COURSE DURATION

1 day

 

TARGET AUDIENCE

Advanced programmers, looking for a mind-blowing experience from the past.

PREREQUISITES

  • Knowledge of  LISP a plus.
  • Please install Racket.

 

OBJECTIVES 

Learn, implement, and apply truth-maintenance systems.

 

 COVERS THE FOLLOWING TOPICS

  • Philosophy: facts versus justification
  • Dependency-directed backtracking
  • Truth Maintenance System: implementation and application

Functional Software Architecture

06 Nov 2020
13:00 - 16:30
Michael Sperber

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