Tutorials:

Introduction to Elm

06 Nov 2019
09:00 - 12:30
Tessa Kelly

Elm is a nice-to-write and nice-to-read language that compiles to JavaScript. It prevents most runtime exceptions, has great performance, enforces semantic versioning, and more. If you want to learn more and get started with Elm, this tutorial is right for you!

 

OBJECTIVES

Attendees should leave the tutorial feeling comfortable with Elm syntax, feeling familiar with the Elm architecture, and knowing where (and to whom) to go to keep on learning and building.

 

TARGET AUDIENCE

Frontend developers who haven't worked with Elm before. Language enthusiasts are welcome as well, but I expect that folks with ML-family language experience may find the intro-to-syntax portion of the tutorial slow.

Thinking concurrently

06 Nov 2019
09:00 - 12:30
Robert Virding

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.

OTP: middleware for concurrent, distributed, scalable architectures

06 Nov 2019
13:30 - 17:00
Robert Virding

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.

Introduction to live coding music with Sonic Pi

06 Nov 2019
09:00 - 12: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.

 

Introduction to SWI-Prolog

06 Nov 2019
13:30 - 17: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.

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.

 

OBJECTIVES

Audience will come away understanding the basic SLD resolution algorithm and knowing basic Prolog syntax, and prepared to become fully competent in the language via independent study.

 

TARGET AUDIENCE

People who want to learn Prolog.

Hands-on Haskell

06 Nov 2019
09:00 - 17:00
Simon Thompson and Dominic Orchard

A full-day tutorial that will give you an introduction to the fundamental ideas underpinning Haskell, and give you experience of using idiomatic Haskell to solve practical problems.

 

OBJECTIVES

  • To familiarise you with the key concepts underlying Haskell: higher-order functions, pattern matching, “algebraic” data types, lazy evaluation, pure functional programming, type inference.
  • To give you experience of using Haskell in practice, using the online repl.it Haskell environment.
  • To introduce you to more advanced features that will allow you to read and write idiomatic Haskell program code.

 

TARGET AUDIENCE

Experienced programmers who want to gain a hands-on understanding the fundamentals of lazy functional programming in Haskell, and to put into practice writing idiomatic Haskell code using, among others, monoids, monads, functors, and GADTs.

Of the three categories beginners / intermediate users / advanced users we’d say that we’re targetting beginners to Haskell who nevertheless have experience of programming in other languages and language paradigms.

 

PREREQUISITES

We expect that you know how to program, but not in Haskell.

OO Programming with Pony

06 Nov 2019
09:00 - 17:00
Sean T. Allen and Sylvan Clebsch

Let's write a chat system in Pony together. The actor model is a natural fit for network programming, so let's use it along with reference capabilities to write an event-driven chat system. By the time we're done, you'll be able to write message-passing based Pony programs, use reference capabilities for performance and correctness, and produce native binaries with C like performance.

OBJECTIVES

Write a chat system in Pony. The participants will be able to write event-driven Pony programs that read from and write to network connections, and they will understand the Pony actor system and reference capability system.

 

AUDIENCE

Developers who are interested in getting their feet wet and learning about the Pony programming language in a friendly hands-on environment.

 

Building an Event Sourced System

06 Nov 2019
13:30 - 17:00
Greg Young

In this tutorial we will actually build up a simple Event Sourced service.

 

OBJECTIVES

To gain understanding of how to build up an Event Sourced model. No frameworks will be used.

 

TARGET AUDIENCE

Those interested in how an Event Sourced system works.

 

PREREQUISITES

Proficiency in most likely Java / C# (people tend to work in pairs and these tend to be the most common languages)