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.

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.

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)

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.

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.