Refinement types decorate the types of a programming language with logical predicates to allow more expressive type specifications. Originally, refinement type based specifications were restricted to SMT decidable theories and allowed automatic “light” verification, for example properties like non-division by zero or in-bound indexing. Verification of such light properties though requires “deeper” specifications, for example “is append associative?” In this talk, we will interactively see how to use the refinement type checker of Liquid Haskell to verify Haskell programs.

The .cabal file defines what encompasses a package in the Haskell ecosystem. It is strictly required if you want to upload your package to Hackage. As such, almost anyone has to write or modify .cabal files at some point in their Haskell career, but due to its unique syntax, this often proves harder than necessary. Recently, Haskell Language Server started to close the gap between support for Haskell and cabal source files, by introducing the cabal-plugin.

In this talk, we are going to take a closer look at the integration of the cabal-plugin into the architecture of the Haskell Language Server and explore its key concepts for providing a snappy, interactive developer experience. We are going to discuss the Language Server Protocol, and the plugin architecture, which allows us to extend HLS with a minimal amount of effort. These features will be explained by doing a deep-dive into the "cabal-plugin", which allows HLS to check .cabal files for syntax errors, provide completions, and even more features that help to read, write and modify .cabal files

With Hécate, we will approach the topic of Effect Systems to write Haskell applications, understand why it is important do have semantic effect tracking in your software, and see how it all fits into the design and maintenance of software systems. We will use Effectful, developed for industrial needs of performance and ease-of-use.

In December I'll be wrapping up my 3-year tenure of the CLC chair and I'd like to present a CLC activities report for this period. Brief introduction to CLC structure, roles and responsibilities; case studies for past CLC proposals; crash course "how to get your proposal approved"; preparations for PVP 1.1; review of core libraries. I hope to demistify the work of the committee and inspire people to apply for vacant positions early next year.

Jacinda is a laconic functional language for stream processing on the command-line. The functional style for stream processing is appealing — maps and folds express stream processing more directly than variable updates — but it requires some cleverness on the backend to make this efficient. I'll show off the Jacinda language, and how to translates this into something for efficient evaluation. Along the way, I'll show off Haskell features for implementing languages that make, and some of the tricks for writing a modern language that didn't make it into the textbook.

Have you ever wondered how synthesizers work? How about building your own, using Haskell?

In this workshop we'll introduce some basic notions of sound synthesis, and will take a look at how to apply these concepts to build different kinds of simple musical instruments, and ultimately make some functional music.

This workshop is aimed at Haskell beginners, and requires no prior musical knowledge. Participants are expected to have their own development environments already configured.

— "Sure, Haskell is powerful and safe, but there's no way an idiot like me can build anything useful with it, right?"

That was me three years ago and maybe you're in the same place now; but this is an illusion.

To deliver us from this kind of negative self-talk, we'll build a small http server using the servant API and through example, realize there's no need to be a wizard to write useful Haskell applications.

This workshop is aimed at Haskell beginners, basic knowledge of HTTP APIs is welcome but not necessary.

Participants are expected to have their own development environments configured, but a gitspace is being worked on for the project and may be available for those who don't have either the knowledge or the time to set up their environment.

Haskell excels in finding programming errors during compile time. We also know Haskell for being lazy and for treating values as immutable. Lazyness and immutability are likely reasons why numerical and statistical analysis of data have never been a particular strength of Haskell.

I have used Haskell extensively during my career as a researcher and have tried to combine the benefits of the strong type system of Haskell with blazing-fast statistical estimators.

In this workshop, we will have a look at a specific class of algorithms used for statistical inference: Markov chain Monte Carlo algorithms. We will get a basic understanding of such algorithms, and, discuss how Haskell can aid us in avoiding common user errors. In particular, we will use the Haskell library mcmc to perform some exemplary analyses