Current database design forces application developers to decide early in the design cycle, and once and for all, what type of consistency the database should provide. At one extreme, strong consistency requires frequent global coordination; restricting concurrency in this way greatly simplifies application development, but it reduces availability and increases latency. At the opposite extreme, there are systems that provide eventual consistency only: they never sacrifice availability, but application developers must write code to deal with all sorts of concurrency anomalies in order to prevent violation of application invariants.

But a system only needs to be consistent enough for the application to be correct. Antidote, an open-source cloud-scale database operates, on a unique middle ground by providing Just-Right Consistency (JRC). It composes various techniques that do not sacrifice availability, unless provably required for the application to execute correctly, including Conflict-free Replicated Data Types (CRDTs) and causal consistency.

In the talk, you will learn how application developers can benefit from Antidote's features in their Haskell applications.

In this hands on session, you will explore building some parsers using one of the many Haskell parser combinator libraries (trifecta). In the first part, we'll get started by writing a simple expression parser. In the second part, you will discover more complex examples depending on audience interest: perhaps parsing more complicated expressions, perhaps parsing other structures such as JSON.

This an introductory level session so you don't need much experience in Haskell at all, but you do need a laptop with Haskell installed so that you can try your own code throughout the session.

You should go through the instructions listed here before the tutorial to get set up.

In this talk, you will briefly explore historical solutions to the problem and discuss their advantages and disadvantages, following that, you will discover a practical introduction to the great machines library from Edward Kmett.

You will learn how the library usage compare to other players in the ecosystem (pipes, conduit, ...), and walk through real world examples giving you a chance to write your own combinators and understand some of the internals.

Tom will briefly outline the data science process and the different kinds of workflows employed, depending on the questions that are asked and the volume and variety of data present. You will learn how, contrary to the common perception, there in fact is a substantial body of work existing in the Haskell open source ecosystem that can solve many of these tasks.

You will focus on two recent projects: combinator libraries predictive analytics and dashboard generation. The R language have mature projects in this area, caret and Shiny respectively. Implementing these projects in Haskell forces us to formalise the types of operations necessary; but this formalisation brings new opportunities in terms of presenting a constructor kit with building block that can be combined in ways that were difficult to imagine in a less formal approach.

In this hands on session, you will explore building some parsers using one of the many Haskell parser combinator libraries (trifecta). In the first part, we'll get started by writing a simple expression parser. In the second part, you will discover more complex examples depending on audience interest: perhaps parsing more complicated expressions, perhaps parsing other structures such as JSON.

This an introductory level session so you don't need much experience in Haskell at all, but you do need a laptop with Haskell installed so that you can try your own code throughout the session.

You should go through the instructions listed here before the tutorial to get set up.

In this talk, you will explore the basic operation of the main optimisations that GHC performs, what users should expect from the compiler and what options they have to control how the optimiser behaves. We will focus on core-to-core passes such as inlining, specialisation, SpecConstr, SAT and so on.

The aim of this talk is to make you think more carefully about how the compiler optimises their code. There will be lots of examples of real world code and toy examples which demonstrate how specific passes work. Ultimately by users better understanding the optimisation pipeline, I hope that library writers experience can feed back into making GHC better optimise modern Haskell code.

In this talk, you will see a scalable approach where individualisation boils down to extending a base workflow description. The problem is related to the expression problem, and our approach is based on solutions in this area. In this approach, the workflow is modelled as a data flow graph in contrast to control flow graphs as traditionally used by workflow systems. Such a graph essentially represents a functional reactive program where the nodes correspond to tasks. The tasks will be organized in a tree, and we express the data flow as functions between attributes of this tree. The description of this tree is an example of an attribute grammar, which we can express as EDSL in Haskell using type level programming. Finally, the attribute grammar formalism allows you to compose the workflow description from small transformable fragments, thereby obtaining the desired extensibility.

Property discovery is the next logical step: it could solve the problem of finding which properties to test. The talk will be presented without any assumption of prior knowledge of testing in Haskell, but familiarity with Haskell is assumed and familiarity with QuickCheck may increase the likelihood that you will appreciate the work presented.

During this talk, you will explore the correctness and performance implications of various degrees of DSL embedding, from simple open term-level APIs to free monads. Free monads afford a particularly high degree of expressivity while remaining syntactically convenient. You will discover practical motivating examples and a real-world implementation of undo/redo within a spreadsheet program (AlphaSheets).

During this talk, you will discover what it »means« to do IO in Haskell, how it differs from ST, and under what circumstances the infamous »unsafe« functions can be used.

In the 1960s, the Kalman filter was applied to navigation for the Apollo Project, which required estimates of the trajectories of manned spacecraft going to the Moon and back. It is now used in so many quantitative fields as to make it impractical to list them all in a summary: navigation and global positioning, tracking, guidance, robotics, computer vision, signal processing, voice recognition, video stabilization, automotive control systems, time-series analysis, econometrics to name but some!

During this talk, you will explore an intuitive introduction to the Kalman filter (not a covariance matrix in sight - well maybe one) and show how data kinds / type level literals can be used to create a filtering and smoothing library in Haskell that has some guarantees that it really does what it says on the tin.

During this talk, you will explore a bit of background in Boolean algebra, focusing on the two fundamental operations, which are generalizations of addition and multiplication, and their identity elements. Julie will extend this to the Monoid typeclass in Haskell and illuminate those Boolean patterns over various types.

Julie will then extend this further, and you will discover how to examine the monoids of conjunction that typically underlie applicative functors and the monoids of disjunction that you find in the Alternative typeclass.

GHC compiles Haskell via Core, a tiny intermediate language based closely on the lambda calculus. Almost all GHC’s optimisations happen in Core, but until recently there was an important kind of optimisation that Core really did not handle well. In this talk, you will learn what the problem was, and how Core’s new “join points” solve it simply and beautifully, by effectively allowing Core to express control flow as well as data flow; there are strong links to so-called “continuation passing style” (CPS) here. On the way, you will explore how GHC’s Mighty Simplifier, which is responsible for many optimisations, works.

Understanding join points can help you are a programmer too, because you can write code confident that it will optimise well. You will discover a rather compelling example this: “skip-less streams” now fuse well, for the first time, which allows us to drop the previous (ingenious but awkward) workarounds.

The Arpeggigon is implemented in Haskell using the frameworks Functional Reactive Programming (FRP) and Reactive Values and Relations. During this talk, you will discover how FRP and its capabilities for handling hybrid (discrete and continuous) time aligns with the temporal and declarative nature of music, thus facilitating developing this kind of application, and by extension applications in domains with similar traits, and how Reactive Values and Relations provide a bridge between the purely functional FRP core of the application and the imperative outside world in a manner that has a relatively declarative reading yet easily accommodates imperative aspects where needed.

This workshop introduces Haskell developers to the purely functional package manager Nix through a series of interactive practical examples. The first hour of the workshop focuses on use of Nix as a tool for Haskell developers: we'll examine how to create declarative reproducible development environments for advanced Haskell hacking, how to extend and customize the Nix package set with our own libraries, and how to integrate external system libraries into our build processes.

The second hour looks at Nix as a tool for Haskell application deployment: we'll use Nix to manage the development, continuous integration, and deployment of a non-trivial GHCJS web application with a Haskell back-end and a PostgreSQL database.

We assume no prior knowledge of Nix, but we do assume that participants have a basic understanding of basic Haskell development with Cabal, cabal-install, or stack. All examples used in this workshop live in the Git repository. We encourage participants to clone that repository and to make sure they have access to a working Nix installation before the event starts. We provide a Docker image for these purposes that users can enter by running the docker-run.sh script found in thenix-workshop repository. Participants who can't or don't want to use Docker should please install Nix by other means as explained on the page.

In this talk, you will explore the incremental-computing package, which allows you to easily build functions with accompanying support for incremental updates. The package contains specifically crafted update algorithms for a set of core functions like filtering and sorting of lists. From these core functions, you can build more complex functions with the help of easy-to-use combinators, and the incremental-computing package will derive the accompanying incremental update methods for you.

This talk is beginner-friendly. You do not need to know dependent types or category theory, and even functors and monads will appear just as familiar and natural (psst!) graph transformations.

The ideas presented in the talk are implemented in the Alga library.

This workshop introduces Haskell developers to the purely functional package manager Nix through a series of interactive practical examples. The first hour of the workshop focuses on use of Nix as a tool for Haskell developers: we'll examine how to create declarative reproducible development environments for advanced Haskell hacking, how to extend and customize the Nix package set with our own libraries, and how to integrate external system libraries into our build processes.

The second hour looks at Nix as a tool for Haskell application deployment: we'll use Nix to manage the development, continuous integration, and deployment of a non-trivial GHCJS web application with a Haskell back-end and a PostgreSQL database.

We assume no prior knowledge of Nix, but we do assume that participants have a basic understanding of basic Haskell development with Cabal, cabal-install, or stack. All examples used in this workshop live in the Git repository. We encourage participants to clone that repository and to make sure they have access to a working Nix installation before the event starts. We provide a Docker image for these purposes that users can enter by running the docker-run.sh script found in thenix-workshop repository. Participants who can't or don't want to use Docker should please install Nix by other means as explained on the page.

If you are writing a medium-sized Haskell for the very first time, you will typically end up with three modules: Types.hs, Utils.hs and Main.hs. While this is a very clear split, it typically doesn't scale very well as applications become larger.

In this beginners talk, Jasper will share with you some practical ways to organise code in Haskell applications. Some of the questions Jasper will answer include:

• When is it a good idea to use something like Monad/Applicative (and when is it not)

• When is it a good idea to invent my own typeclass (and when is it not)

• How do I design interfaces and services like in OOP?

During this talk, you will explore the experience gained building an EDSL for the KDB/Q database language at Standard Chartered. You will start with their rationale for choosing such an approach; then review techniques such as Higher-order abstract syntax (HOAS), recursion schemes and embedding Algebraic Datatypes. Finally, you will reflect on the success of the project and discuss the lessons learned.

The concept of lenses in general, and the lens library in particular, have revolutionised modern Haskell programming. The lens library is full of abstractions that allow expert users to write amazingly concise code, but these are sometimes baffling to the uninitiated. Not for nothing has the library been described as a separate language that happens to be embedded in Haskell. Significantly, the key concepts expressed in the library (optics such as lenses, traversals and prisms), are not in fact abstract data types. Rather, they are type synonyms, which expose the underlying implementation. This gives a lot of power and flexibility to combine optics, but allows implementation details to leak into inferred types and error messages.

In this talk, you will discover an attempt to capture optics such as lenses using abstract data types, while maintaining as far as possible the expressive power of the lens library. Clearly distinguishing between the interface and implementation of optics will help illuminate their nature and purpose. Moreover, I will reflect on the power and limitations of abstraction in Haskell itself.

This talk will be suitable for Haskell programmers of a range of skill levels. Only basic Haskell knowledge will be required, and familiarity with the lens library will not be assumed, although having been baffled by it at least once is a worthwhile experience for anyone.

Fortunately, recursion schemes come to the rescue. They allow for a clear and concise definition of recursion, while being guided by the typechecker. During this talk, you will explore the basic theory behind them but will not require advanced knowledge of mathematics. Recursion schemes can greatly benefit from a more widespread usage and will try to convey the practical ways in which they can be used in real life programs.

Herculus is an innovative tool for working on relational data, with a spreadsheet-like user interface. Arbitrary user-defined ADTs can be used as column types, and a statically-typed functional language like Haskell is used to declare data transformations. As a result, you can quickly build complex data management applications with zero boilerplate.

In this talk, you will learn about the guiding design principles and concepts behind Herculus, see some applications, and discuss planned features as well as challenges.

During this talk, you will explore an overview of the structure of the native code generator and the mapping of Cmm language constructs to assembly code. Haskell pattern matching simplifies peephole optimisation.

Examples will be based on the Linux 64-bit PowerPC backend but should be accessible to anyone with basic knowledge of assembler.

Our toolchain is composed of the compilation and packaging tools Andronaut and CuriOSity, the FRP testing framework Haskell Titan, our game and app development libraries, and our application templates.

Together, they allow to create, compile, test, package and publish a new app directly to online stores in a matter of seconds.

Property-based testing consist of generating random values and check that some properties hold on the result of the function under tests. This technique is manifested for example in the QuickCheck library. The QuickCheck library provides conjunction, disjunction and implication combinators to form complex properties from simple ones, but in case of failure the reason of failure is not clear.

Specification Based technique can be formalized in modern Haskell. This formalization can be used to aim traceability of test failures. At the same time it keeps the compositional structures of the Property based resulting a clean and readable testsuite and software architecture. The result of test design can be reused in different levels of testing, from unit, integration, stress, etc. In this talk, you will discover the Specification-Based techniques through their Haskell implementation, and you will explore an example the testing of a semi-complex application.

During this talk, you will discover a type safe way of bringing together domain actions and rules by leaning on most recent GHC v8.2's module 'Type.Reflection' and 'Refl'. The ultimate goal is to saturate your multicore CPUs with work safely, and thus making customers happy.