MuniHac 2022

MuniHac is back in 2022!

October 7–9, 2022 • on-site in Munich

About MuniHac

We're glad to announce that MuniHac will be back this year, as an on-site event in Munich.

MuniHac is a three-day Haskell hackathon and conference hosted in the beautiful city of Munich. It's aimed at both Haskell beginners and experts, featuring both a beginners track and talks from Haskell experts from all over the world. And it's free (as in beer)! MuniHac 2022 will be primarily on-site, but like in the previous years, talks will recorded and available on YouTube, too.

MuniHac 2022 will be take place at a new location, the TNG office at Arabellapark, Munich. This new location provides space for more people, and is a lot closer to the city center! Please take the new location into account when booking your accomodation!


Please note that all times are CEST.

Friday, Oct. 7, 2022
Time Hackathon Talks Workshops
8:30 Doors open & Registration
9:30 Opening
9:45 Project Marketplace Beginners Workshop
10:30 Hack on
11:30 Keynote: Gabriella Gonzalez: Minmaxing Slay the Spire with Haskell
12:30 Lunch
13:30 Hack on Joachim Breitner: Getting recursive definitions off their bottoms Beginners workshop (continued)
14:45 Michał J. Gajda: Mathematics of debugging a Haskell program
16:00 Cass Alexandru: Structured Traversals for (Multiply) Recursive Algebraic Data Types
17:30 Official end
19:00 After-hack get-together (not in the official part of the hackathon): Restaurant "St. Emmeramsmühle"
Saturday, Oct. 8, 2022
Time Hackathon Talks Workshops
8:30 Doors open & Registration
9:00 Hack on Franz Thoma: Generative Art in Haskell
10:45 Andres Löh: Implementing a type inference algorithm
12:30 Lunch
13:30 Hack on Krzysztof Gogolewski: Quines and metaprogramming Finley McIlwaine: Profiling Memory Usage With eventlog2html and ghc-debug
14:45 Michael Sperber: How to Deep Learn with Categories
16:00 Keynote: Ben Gamari: Improvements in observability in GHC 9.6
17:30 Official end
Sunday, Oct. 9, 2022
Time Hackathon Talks
8:30 Doors open
9:00 Hack on
10:00 Bavarian Breakfast
11:30 Keynote: Nicolas Wu: Modular Programming with Effects
13:30 Snacks
14:00 Project presentations
17:00 Doors close


Project Marketplace & Project Presentations

The main focus of MuniHac is getting together and hacking on Haskell projects. At the beginning of MuniHac, there will be a project marketplace where everyone can do a short intro to their project, and look for people who would like to join. If you want to present a project or idea, ideally you would prepare a short summary or pitch, we expect a lot of projects! If you haven't submitted your project on the registration form, that's no problem: You can be spontaneous as well!

On Sunday, there will be a projects presentation, where everyone can show their progress.


Minmaxing Slay the Spire with Haskell

Gabriella Gonzalez

This talk will explain how to compute the optimal strategy and outcome for a simple Slay the Spire battle (a rogue-like deck building game). Part of the talk will be Haskell-agnostic (explaining the basics of Slay the Spire and minmax algorithms) and part of the talk will be Haskell-specific (introducing cool tricks like probability monads and automatic memoization).


Getting recursive definitions off their bottoms

Joachim Breitner

Haskell claims to be a declarative language, where you just write down some equations, and suddenly the variables contain the solution to these equations. This works even with recursive equations, but only in some cases: defining recursive functions, of course, but also cyclic data structures. One can even apply so-called knot-tying tricks, where a lazy data structure is filled with values that refer to that data structure! For example, one can very elegantly calculate the reachable nodes in a graph.

… until the graph is cyclic, and suddenly our nice elegant Haskell program silently runs in circles and will not produce an answer.

This is unfortunate: The involved equations, although recursive, do nicely declaratively describe the solution we want! So let’s make it happen!

We’ll see types (Booleans, Sets) that seem to behave just like the normal ones, but recursive definition somehow magically produce the expected result. And all that in pure code, no monads anywhere! We’ll see a few use cases that can suddenly be solved much more elegantly.

Then we’ll look under the hood of this (arguably) safe API, won’t be deterred by unsafePerformIO, and find some very imperative, monad-infested, concurrency-worried code that implements a form of “propagator”. We’ll notice that there is plenty we can do to improve their performance, but won’t actually go there. Instead, we’ll turn back to the “pure” interface and discuss together if that is still really “pure”, and what does that mean anyways.


Mathematics of debugging a Haskell program

Michał J. Gajda

Can you use a silver bullet to shorten time to debug Your Haskell programs? Yes, and the name of the bullet is mathematics! We propose a way to roughly estimate complexity of debugging activities, and ways to reduce time spent on finding this "small" typo.


Structured Traversals for (Mutually) Recursive Algebraic Data Types

Cass Alexandru

Structured traversals (a.k.a. recursion schemes) show up all the time when working with inductive algebraic datatypes (s.a. lists), once you know what to look for. We examine the simplest of these, the humble catamorphism (foldr for lists), following its journey from motivation, then via its origin in category theory into the more turbulent waters of mutually recursive datatypes (s.a. ASTs), putting Haskell's amenities for type-level programming and basic dependent types to work along the way.

The theoretical foundation for the presentation is the multirec paper by Andres Löh et al. The presentation has a literate Haskell source, so all code on the slides is real. Additionally, the repo has a pinned nix shell so you can build everything at home. Link to the repository:


Quines and metaprogramming

Krzysztof Gogolewski

Quines are programs printing their own source code. How to write a Haskell program printing a Python program printing a Ruby program printing back the original Haskell program? What other forms of self-reference are possible? What can this teach us about metaprogramming? How does this relate to modal logic?


How to Deep Learn with Categories

Michael Sperber

One of the uses of Conal Elliott's ConCat infrastructure for compiling with categories is implementing Deep Learning. ConCat implements the automatic differentiation needed to compute gradients. It can also be used to transform the resulting code to utilize a GPU via the Accelerate framework. The talk describes how these pieces fit together in an industrial application, what the advantages are over the dominant Python-based frameworks, as well as challenges with using the framework. I also intend to conduct a hacking session on our ConCat codebase.


Improvements in observability in GHC 9.6

Ben Gamari

While Haskell can be a joy to use in production, it has historically lacked many of the observability mechanisms that other languages take for granted. Things like ubiquitous availability of backtraces, reliable profiling tools, introspection on threads of execution, and heap inspection tools have long been lacking. Happily, with increased commercial adoption has come a sharper focus on addressing these shortcomings. In this talk we will discuss a variety of improvements in these areas, with particular focus on features coming in GHC 9.6 including the long-awaited exception backtrace proposal. We will try to describe both the user-facing functionality as well as some of the innards which make this functionality possible.


Modular Programming with Effects

Nicolas Wu

A distinctive feature in the design of Haskell was the inclusion of monads as the means of incorporating effects into programs. While it is entirely possible to write effectful programs in a single monolithic monad, there are advantages to decomposing a monad into smaller building bricks that can be layered on top of each other: smaller components are more easily reused and can be flexibly exchanged for others when needs change and improvements are made. Traditionally, this kind of modularity was achieved through the use of monad transformers, and while this approach works well, it imposes a proof burden on the implementer. This talk will explore algebraic and scoped effects as a means of expressing effectful programs where the proof burden is automatically discharged.


Haskell Beginners Workshop

David Luposchainsky

Goal of the workshop is tackling the very basics of Haskell development. After setting up the compiler, we’ll be going over the basic language features, with frequent small exercises to get hands-on experience. In the end, we’ll have seen many concepts core to Haskell development, reaching a certain degree of familiarity with the language to serve as a good basis for further projects.


Profiling Memory Usage With eventlog2html and ghc-debug

Finley McIlwaine

Understanding and analyzing the memory usage of Haskell programs is a notoriously difficult yet important problem. Recent improvements to GHC's profiling capabilities, along with better tooling, has made it much easier to deeply and precisely analyze the memory usage characteristics of even large Haskell programs.

This workshop aims to present two such tools that allow high and low level memory usage analysis of Haskell programs: `eventlog2html` and `ghc-debug`. We will learn how to set up and use `eventlog2html` to generate high-level visuals and statistics of our program's execution. We will also learn how to set up and use `ghc-debug` to precisely and programmatically explore our program's low-level memory usage profile.

We will examine these tools by using them on several pre-prepared Haskell programs. The workshop aims to be beneficial to Haskell programmers of all levels. Beginner Haskell programmers can expect to gain a deeper understanding of lazy evaluation and the impacts it can have on program performance. Experienced Haskell programmers can expect to gain an understanding of exactly what these tools have to offer and the skills necessary to use these tools on their own Haskell programs.


Generative Art in Haskell

Franz Thoma

In this tutorial, we’re going to dive into the world of 2D geometry, recursive patterns and randomness to generate art from Haskell code. Using a beginner-friendly geometry library, we’ll build up more and more interesting 2D images that are generated algorithmically or even interactively.

I've prepared a few examples like Voronoi patterns, Penrose tiling, and bouncing rays. This is a guided tour, so feel free to lean back and enjoy, but there will be plenty of time to code along and bring your own ideas to the Canvas!

As a bonus, I'll bring a pen plotter to MuniHac, so we'll be able to output your artwork to physical paper!


Implementing a type inference algorithm

Andres Löh

In this workshop, we are going to look at the type inference algorithm that forms the core of Haskell's type system, Damas-Hindley-Milner type inference.

We are going to look at simple examples, discuss the rules of the underlying type system and implement the inference algorithm for a simple lambda calculus with let bindings and a few added language contructs.

This workshop is suitable for relative beginners of Haskell as well as more experienced users who want to systematically understand how basic type inference works and can be implemented. The Haskell we are going to write will mostly be free of advanced constructs, and no prior experience with type systems or type theory is assumed.


Want to keep in touch and receive updates about MuniHac? We have a Twitter account, a mailing list, and a Slack workspace.

You can reach us via email: