16 - 19 June 2020
Poznan, PL

Haskell Summer School

=<< Monadic Party >>=

Four days of Haskell nerding. Lunch included. Bring your laptop


With the COVID pandemic happening around the world, there is a large chance of our summer school not being able to take place in June. Poland currently has an international travel ban and all gatherings of more than fifty people are forbidden.

Taking this into account and thinking about the safety of our speakers and attendees, we will be postponing the summer school. Our current plan is to have it in October, though it is hard to predict things exactly at this stage. Because of that we have issued full refunds to the attendees.

This is a really hard decision to make and we are not taking it lightly, especially given all the preparation and hard work that made the 2020 edition possible. We want to give a big thank you for all your support.

About the event

Monadic Party is a four-days long Haskell summer school. Our vision is to teach in depth with each talk taking between four and six sessions. There are three tracks, one for beginners in Haskell and two aimed at intermediate to advanced Haskell programmers.

For attendees that arrive on the 15th, we have a preparty lined up.

The venue is a recently restored lovely old building at Mlynska 12 where we have the whole highest floor at our disposal. The only thing you need is a ticket, laptop and a place to sleep and you're good to go. Catered lunch, tea and coffee is included in the ticket price.

Getting There

When traveling from ZuriHac, we highly recommend taking a train to help the environment a bit. There is a train on the 15th of June, leaving Zurich at 9am and arriving in Poznań at 8:27pm (changes in Basel and Berlin). When buying well in advance, it costs 99,90 Euros. You can book it here.

We will hold the summer school at Mlynska 12, Poznan, Poland. The venue is in the Old Town, a walking distance from the town square. We would love to help you with choosing a place to stay. If you have any questions, please email us at [email protected].

Inside the city of Poznan there is a good public transporation system with a dense network throughout the city.

Scholarship Programme

We are deligted to offer a means based scholarship programme. If you are unable to attend the summer school because of financial reasons, we have a number of fully funded places available. Everything needed for you to attend is covered - travel to the event, accommodation and the ticket itself.

The scholarship applications are now closed, if you have applied, expect a message from us between 23rd and 27th of March.

Ryan Moore

Quantum Cyclocomplexitor in Chief at MX

Christophe Scholliers

Professor in computer science at the University of Gent

Chris Penner

Acro yogi, chiptune artist, programmer

Ramon Soto Mathiesen

A passionate computer scientist devoted to SAFE Haskell

Michał Gajda

Promoting Haskell for Data Scientists

Philip Wadler

Professor of Theoretical Computer Science at the University of Edinburgh

Justin Woo

PureScript and memes

Tom Sydney Kerckhove

Professional Weirdo. Technical Leader and Engineering Manager at FP Complete

Marcin Szamotulski

Networking Lead at IOHK

Krzysztof Gogolewski

Works on Linear Types in GHC at Tweag

Michał Miszczyszyn

Full Stack Developer at X-Team

Laurens Duijvesteijn

Builds infrastructure at Channable

Andrew Lelechenko

Software developer from London with a strong background in mathematics and computer science

Alexander Granin

Haskeller, speaker, researcher, author. Independent consultant, Haskell architect

Maciej Kowalski

My passion for programming oscillates between frontend and backend. So I am the middleman

M Ian Graham

15-year game industry veteran and pragmatic functional programmer, currently freelancing in Tokyo

Zans Mihejevs

Functional programmer bridging the gap between programming language research and application


Christophe Scholliers:

Learning Haskell: a project-based approach - 6 hours



This track consists of a crash introduction to Haskell, in two parts of theory and practice. In the theory, we start from scratch and finish with the concepts of functions, type classes and algebraic data types. Armed with this knowledge we switch to the exercise track where we will implement two small games: Snake and Tetris. We will be using an online exercise platform which will guide you through the various stages of implementing the games.

About the speaker

Professor Computer Science at Ghent University, teaching functional programming, foundations of programming languages, logic programming and software engineering.

Ryan Moore:

Fun with applying Applicative - 4 hours



With all the love surrounding the mysterious monad sometimes it’s sibling type class Applicative gets left out in the cold. I’m this workshop we will take a deep dive into what it takes to spot an applicative, build our own instances and *apply* our knowledge through the use of two powerful libraries that leverage applicative to parse and validate text.

About the speaker

Ryan Moore works as a software engineer at MX to ensure that all people can have access and ownership of their financial data. Ryan is passionate about functional programming, experimental, music that’s experimental, mathy or grungy and volunteers teaching refugees coding alongside the Utah State Refugee Education and Training Center.

Tom Sydney Kerckhove:

Real World Haskell - 6 hours



This workshop walks you through how to work on a Haskell codebase from start to finish. Everything from starting a project, standard tools and libraries, testing from scratch, benchmarking from scratch and the development lifecycle will be discussed.

About the speaker

Professional Weirdo. Technical Leader and Engineering Manager at FP Complete.

Justin Woo:

Full Stack PureScript - 4 hours



In this talk, Justin will start by going through the PureScript language, both in the type level and what the generated JavaScript code looks like. From there, the sessions will go through how to work with the intersection of the Foreign Function Interface of PureScript and types, in order to help users learn how to write full stack applications in PureScript on the browser and Node.js.

About the speaker

Justin is an American in Finland. He has been using PureScript at work for over two years, deploying to browsers, AWS, and more. Justin is best known not for his PureScript ecosystem work or educational blog posts, but for his memes on Twitter.

Maciej Kowalski:

Introduction to ELM - 6 hours



During this workshop we will solve a single problem: building a Reliable, Scalable, Maintainable SPA (single page application). Or we will learn how to go from 75K+ React Beast, that is flaky, builds slow, size >1Mb, and scares away newcomers (me), to a "yay I can go to work" Elm app

Four months ago I joined a startup and I very much enjoy the work. During this short period we developed 50k+ line backend service, with 1000+ tests that take <2m to run, that is a pleasure to work with, refactor and extend.

Sadly the frontend 75k+ line app we developed was a problem for business, and developers. The biggest pains it has (imho) are:

  • build times ( CI takes 4x 15-20min ).
  • production errors (undefined is not an object, null is not an object and even more hairier ones).
  • typeless (pure js) -> refactoring is not an option.
  • 1.5Mb + bundle sizes.
  • i hate this code feeling.
  • what does this application do? (hard to tell without reading it all).

If any/many of these sound like pains you have/had, I encourage you to join this workshop and learn a new way how these problem can be solved. During the workshop You will:

  • learn how to build a SPA in Elm.
  • learn how strong guarantees that Elm provides solve above pains.
  • as a sideeffect, gain a lot of FP knowledge.
  • see how Elm makes coding fun.
  • make you not want to go back to working in any other frontend technology.

About the speaker

My passion for programming oscillates between frontend and backend. So I am the middleman.

Michał Miszczyszyn:

Introduction to ReasonML: build a cross-platform game - 4 hours



ReasonML is a programming language enabling you to create fast applications in a type-safe manner. It compiles to native binaries (MacOS, Linux, Windows, Android, iOS) or to JavaScript! During this workshop you'll get to know ReasonML, learn the basics of functional programming, and create a cross-platform computer game! You'll learn everything on real-life examples, and you'll be able to see your progress as the game becomes more and more interactive when you solve the exercises.

About the speaker

Michał is a full-stack developer not afraid to use any technology. Currently working with X-Team. Entrepreneur, activist, blogger at typeofweb.com, speaker, and teacher. He's also a community organiser running meet.js Gdańsk and a few editions of meet.js Summit. Loves types, functional languages, pair programming, and sharing ideas.

Alexander Granin:

Designing real-world applications in Haskell with Free Monads - 5 hours



We need an understanding how to build real-world applications in Haskell. This is the biggest demand from the Haskell community according to the yearly surveys. We need design approaches, software architectures, best practices and design principles. We need not just a set of distinct ideas but rather a complete methodology of how to build complex applications that will be manageable, testable, simple. Many approaches emerged from the Haskell world recently: Final Tagless, ReaderT pattern, Service Handle pattern, effect systems. But my approach is based on Hierarchical Free Monads, my own methodology that I successfully used in several companies.

In the workshop, you’ll learn how to use Free monads for layering your application, for designing subsystems, for separating interfaces and implementation. You’ll know how to add support of SQL DB, implement logging, add external services interaction. You’ll know how to create a REST servant-based backend that will be using your business logic for doing stuff. You’ll see that the Free monadic approach allows you to do functional and integration testing easily.

For more info, consider my free book Functional Design and Architecture.

About the speaker

Haskeller, speaker, researcher, author. Independent consultant, Haskell architect, developed my own methodology (Free-monad based) of writing complex Haskell applications. Used these ideas in real projects. Working on the book "Functional Design and Architecture" which described these ideas, giving talks at many international conferences. Currently consulting Juspay (Bangalore, India), a financial company. Their main codebase (200K likes of PureScript) is based on the Free monadic framework of my design.

Michał Gajda:

Higher Kinded Datatypes for Data Science - 6 hours



We have a growing number of libraries that use HKDTs to morph input types into type of parsers, or type of errors. That allows us to streamline typed data analytics pipeline, database building, and option parsing.

The workshop will be formulated as a series of quests to analyze the input, and get nice graph representations.

To keep advanced listeners on their toes, I will also introduce optional side-quests with Type Families, Generics, and `barbies` library for generic HKDT manipulation.

About the speaker

Used Haskell to write fast bioinformatic parsers, count beans in financial industry, and analyze own source code too. Now promotes it as a tool of choice for Data Science.

Chris Penner:

A Practical Introduction to Optics - 2 hours



This talk will help you understand what Lenses, Folds, Traversals, Prisms and Isos are used for and how they fit together. You should feel comfortable getting work done with optics using a library of your choice by the end.

Though it's recommended that you have an intermediate level of Haskell, this talk is suitable to folks completely new to optics or to those who've used them casually.

About the speaker

Developer, teacher, aspiring opsimath, if Cunningham's law was a person. Author of the lenses book: Optics By Example

Andrew Lelechenko:

Low-level Haskell - 4 hours



In the age of dependent types low-level guts of Haskell are often overlooked. Most of us grew fascinated by polymorphism, functors and effect systems and never looked back. This talk is an invitation to go deeper, back to the very roots and discover primitive operations below. Participants will learn how to operate on unboxed data and primitive arrays, and combine them with the high-level code, aiming for better performance and - even more important - relaxing pressure on garbage collector. Topics covered:

  • Lifted and unlifted, boxed and unboxed data. Basics of levity polymorphism. Strict and lazy pattern-matching, understanding of GHC strictness analysis. Introduction to Core language.
  • Low-level arithmetic of fixed and arbitrary precision. Low-level comparisons. Allocations and how to avoid them. Writing bindings to `libgmp`. Examples: modular exponentiation, factorials.
  • Crash course of bit fiddling, covering reversals, population count, leading/trailing zeros, parallel deposit and extraction. How to handle different architectures? Examples: boolean polynomial.
  • Raw arrays and memory access. Mutable and immutable arrays. Introduction to `primitive` package. Atomic updates in multi-threaded environment. Examples: table lookups, bit sets.

About the speaker

Andrew is a software developer from London with a strong background in mathematics and computer science. After receiving his PhD degree, he went into industry and ended up developing a compiler of the domain-specific language for finance and trading, implemented in Haskell. His main open-source contributions are mathematical libraries with a focus on performance.

M. Ian Graham:

Rust for the Working Haskeller - 6 hours



Rust is a memory-safe system programming language that uses functional concepts for safety and productivity while maintaining performance similar to C and C++. In this workshop you'll learn how to use Haskell and Rust together to build blazingly fast programs while keeping your sanity.

We'll start by covering the basics of Rust, how to call it from Haskell via FFI, and performance testing methods to make sure you're using the right language in the right place. Then we'll use a small game made in pure Rust to go hands-on with advanced topics including session types and parallel processing. You’ll leave the workshop unafraid to mix in a dash of Rust whenever your project could benefit.

About the speaker

Ian is a 15-year game industry veteran and pragmatic functional programmer, currently freelancing in Tokyo. He specializes in online games and social systems, using languages like Haskell and Rust to bring some order to the chaos of game development.

Marcin Szamotulski:

Learning Haskell FFI based on Win32-network package - 2 hours



In this workshop we will learn how to use Haskell's ffi, how to share data between C code, and review a heavy architecture and implementation of Win32-network (which heavily uses FFI calls) package which implements asynchronous IO windows interface (also called Overlapped IO in Windows nomenclature) - so we'll get familiar with it too. The workshop is dedicated to intermediate haskellers, or beginners who know basic C programming. C programming is not a prerequisite, but knowledge of pointers will certainly help.

About the speaker

Networking Lead at IOHK

Philip Wadler:

Programming Language Foundations in Agda - 6 hours



This course is in two parts, each three hours long. Part I is an introduction to formal methods in Agda, covering datatypes, recursion, structural induction, indexed datatypes, dependent functions, and induction over evidence; with focus on formal definitions of naturals, addition, and inequality, and their properties. Part II is an introduction to formal models of simply-typed lambda calculus in Agda, including reduction, type rules, and progress and preservation, and (as a consequence) evaluation of lambda terms. Part II depends on Part I, but Part I can be skipped by those already familiar with Agda.

The textbook is freely available online: Programming Language Foundations in Agda

The book has been used for teaching by me at:

  • University of Edinburgh (Sep-Dec 2018, 2019)
  • Pontifícia Universidade Católica do Rio de Janeiro (PUC-Rio) (Mar-Jul 2019)
  • University of Padova (Jun 2019)
  • ICFT Tutorial (Sep 2019)
and by others at
  • University of Vermont
  • Google Seattle.
The book is described in a paper (of the same title) at the XXI Brazilian Symposium on Formal Methods, 28--30 Nov 2018, which is available here: http://homepages.inf.ed.ac.uk/wadler/topics/agda.html#sbmf The paper won the SBMF 2018 Best Paper Award, 1st Place.

About the speaker

Philip Wadler is Professor of Theoretical Computer Science at the University of Edinburgh and Senior Research Fellow at IOHK. He is an ACM Fellow, a Fellow of the Royal Society of Edinburgh, and editor-in-chief of Proceedings of the ACM for Programming Languages. He is past chair of ACM SIGPLAN, past holder of a Royal Society-Wolfson Research Merit Fellowship, winner of the SIGPLAN Distinguished Service Award, and a winner of the POPL Most Influential Paper Award. Previously, he worked or studied at Stanford, Xerox Parc, CMU, Oxford, Chalmers, Glasgow, Bell Labs, and Avaya Labs, and visited as a guest professor in Copenhagen, Sydney, and Paris. He has an h-index of over 70 with more than 25,000 citations to his work, according to Google Scholar. He contributed to the designs of Haskell, Java, and XQuery, and is co-author of Introduction to Functional Programming (Prentice Hall, 1988), XQuery from the Experts (Addison Wesley, 2004), Generics and Collections in Java (O'Reilly, 2006), and Programming Language Foundations in Agda (2018). He has delivered invited talks in locations ranging from Aizu to Zurich.

Krzysztof Gogolewski:

The type system of GHC - 4 hours



How does the type checker of GHC work under the hood? I will discuss the basic rules, describe the multitude of extensions and experiments added over the years and give some ideas about the future.

About the speaker

Software engineer at Tweag, working on linear types.

Chris Penner:

Implementing Profunctor Optics - 2 hours



Ever wonder how optics actually work behind the scenes? This talk is a friendly introduction to the machinery behind implementing a profunctor optics library. We'll also touch on the Van Laarhoven optics encoding along the way.

It's recommended you be comfortable using optics to perform simple tasks. The "Practical Introduction to Optics" workshop should prepare you for this workshop.

Though it's not strictly necessary, it's recommended that you look over the Contravariant Functor and Profunctor typeclasses before attending.

About the speaker

Developer, teacher, aspiring opsimath, if Cunningham's law was a person. Author of the lenses book: Optics By Example

Zans Mihejevs:

Implementing a Dependently Typed Language from Scratch - 4 hours



In this talk I will develop a programming language based on Classical Logic, which allows explicit reasoning about the control flow of the program. The focus will be on the implementation issues that arise when developing a type system in Haskell, as well as the best practices for translating languages presented in type theory papers into Haskell code. Time allowing, I will also show the benefits of using Classical Logic for structuring programs with effectual computation.

About the speaker

Functional programmer bridging the gap between programming language research and application.

Ramón Soto Mathiesen:

Better software for Voting Machines - 4 hours



In a perfect world, we should never (EVER) have to rely on voting by electronic means, as we sadly, haven't found any solution that is more trustworthy and secure than the traditional framework of pen and paper combined with people, of different backgrounds and political views, to count votes.

Given that more and more countries are pushing for electronic voting, to reduce the cost of this process, but for the most, not always getting it right from either of the four pillars of voting: Functionality, Security, Resilience and Trust seen from the perspectives of Law, Society and Technology.

We would therefore like to provide a "real" open source implementation, copyleft licensed, that doesn't need to be hidden under a "legal wall" as for example a solution provided by the Postal service of a country known for its watches and chocolate. The approach will be based on the Principle of Least Privilege (PoLP), since Haskell is among the very few programming languages that can enforce this at compile-time, which should provide more trustable and auditable software.

About the speaker

A passionate computer scientist, with flair for functional programming languages and business, that advocates for: correctness, code-quality and high-standards. Ramón seem to have discovered his particular Holy Grail in SAFE Haskell, which he tries to use to make software that can comply with the EU GDPR, by technical means.


Michał Kawalec

Software engineer at X-Team, speaker, Haskeller, FP evangelist, secretly a physicist

Ewa Krużyńska

Monadic Party and Monadic Warsaw organizer, LGBT+ activist

=<< Partners >>=

Code of Conduct

We are following the Berlin Code of Conduct. If you ever feel it has been breached, do not hesitate to contact one of the organizers.