This is an experiential workshop, we will code together, and explore ideas from first principles. You will need GHC 8.*

The workshop is pitched at Haskell enthusiasts (you don't have to be hardcore at Haskell, I am not!). We'll be writing code together and apart, reflecting on code and ideas, and getting into and out of trouble.

Patterns for IO

Experience the 3 styles of IO programming in Haskell, in the order in which they evolved:

* imperative style (the status quo)
* Lazy IO and its limitations
* Iteratee IO, the solution to Lazy IO

As we compare the different styles, we will pay attention to

* what controls evaluation
* space and resource management
* the relationship between producer and consumer

From Foldable, Traversable to Lenses

We follow the evolution of fold and map on lists, to their generalisation over arbitrary types with the Foldable and Traversable type-classes.

The Lens library raises Foldable and Traversable to an even higher level of abstraction. We will see how the Lens library gives a unified vocabulary for traversal of arbitrary data structures.

Functor, Applicative, Arrow, Monad

These data types fall on a spectrum of power and generality (Functor being the most general, and Monad the most powerful). By experiencing how these types differ in the way they compose, we can gain a clearer understanding of where and how each type may be used.

Dependent Haskell / Type-level programming 101 (bonus material)

In modern Haskell, the line between types and functions have blurred, types have become as powerful and expressive as functions. Since we can write functions on type-level, we can do whatever we like with types! Almost.

Let's write some type-level code, and see why Dependently Typed Programming matters.

Datatype Generic Programming (bonus material)

This style of Haskell programming is based on a simple technique: instead of defining functions for ad-hoc types, we deconstruct our types into a more fundamental type representation, and then write generic functions against the lower-level type. These generic functions are impervious to changes in the original, higher-level data types.

We will experience datatype generic programming from first principles, and along the way uncover the key ingredient in the magic sauce called GHC.Generics.

There are several great books and courses that serve as an introduction to functional programming in Haskell. Typically, these introductions focus on the original core of Haskell ("Haskell 98").

However, going from there into real world Haskell systems can be a bewildering experience. This is because Haskell has evolved significantly since Haskell 98. In this talk we will investigate the key advances in the type-system that make up "modern Haskell".

• type-system extensions: GADTs, multi-param type-classes, functional dependencies, ...
• kind-system extensions: type functions, kind polymorphism, type promotion, ...

By taking a historical perspective we will look at why new language extensions were introduced, and the context in which they first appeared. This approach gives us a layered view of seemingly disparate language features.

We will see that the evolution of the type system has been a steady march from term-level programming to type-level programming, and ultimately dependently-typed programming in Haskell.

(This talk will draw from the book "Haskell Design Patterns")

There is a growing need for scalable, realtime business systems that are continuously running and highly-available. Two very different frameworks/approaches you could use to build such systems are Storm and Akka.

Systems created with Storm or Akka are distributed, at runtime, on as many machines as you choose. The inherent concurrency implied by this brings the issues of State, Time and Failure into sharp focus. Functional programming has much to say about dealing with state and time; not surprisingly, both Storm and Akka have strong roots in functional languages (for Storm it is Clojure, and for Akka, Scala).

In this talk we'll explore the core concepts and challenges of distributed computation; the role of functional programming in concurrent distributed computing; we'll take a look at Storm and Akka, by example, and see that as different as these 2 approaches are, the underlying difficulties of distributed computation remains evident in both: dealing with time, and dealing with failure.