The Haskell Hackathon is an international, grassroots collaborative coding festival with a simple focus: build and improve Haskell libraries, tools, and infrastructure.

This is a great opportunity to meet your fellow Haskellers in real life,
find new contributors for your project, improve existing libraries and tools or
even start new ones!

This year, we want to have a special focus on beginners. During the whole event there will be beginners' mentors on site who you can directly approach at any time with any Haskell-related question you might have. Also, we will be having introductory talks for beginners, focusing on conveying experience that cannot simply be gathered by reading books or blog posts.

Sponsors

Venue notice

Visitors are not allowed to take any photos in the venue. No distribution of any Google work-related information visible inside the building. Visitors should always have a visitor sticker visible. ​Guests ​can not be left ​unattended.

News

10th of February 15

Added wiki page

4th of March 15

Registration is open

6th of March 15

Duncan Coutts confirmed as second invited speaker; swapping days with Edward.

Notes

(*1) If you are hosting a project, please be there to both introduce it and give a summary afterwards. Also, please add your project to the projects page.

(*2) Only if the weather permits it. Saturday same time will be the auxiliary date.

(*3) We will provide sandwiches or similar snacks for you. Because of limited budget we cannot serve a real lunch meal. Of course you can go to a local grocery shop and bring food and drinks with you.

(*4) Beginners' track; Those talks will happen in a separate area, so if you don't want to attend you won't be disturbed.

Talks

Edward Kmett

Title: Discrimination is Wrong: Improving Productivity

Abstract:
This talk is a case study in library design in Haskell.

Fritz Henglein has shown through a number of excellent papers how to use "discrimination" to do lots of things in O(n): Sorting many more data types than you'd expect, table joins, etc.

In the process of optimizing this approach and wrapping it up in a form that can be easily consumed, we'll take a lot of detours through the different ways you can think about code when optimizing Haskell.

We'll need some category theory, from a deeper understanding of monoids to Day convolution.

We'll need to consider final and initial encodings.

We'll need to drift down to low level system concerns from building a custom foreign prim to nesting unsafePerformIO within unsafePerformIO.

We'll need properties of laziness from productivity to IVars.

Along the way we'll find and fix a small problem with the initial discrimination paper, which opens the door to streaming results, rather than having to wait until all the input is ready.

Duncan Coutts

Title: Better faster binary serialization

Abstract:

This talk is a case study in low level optimization in Haskell.

We have existing libraries for binary serialization but the mainstream
ones use bad formats, and could always be faster. We will look at new
work to improve on the existing libraries, to use a new better format,
and to dramatically improve performance.

We will go into the details of a number of standard and new techniques
for getting a good combination of performance with features and
flexibility.

Jannis Limperg

Title: Monads by example

Abstract: The Monad type class is used extensively in both the Haskell standard
library and numerous third-party libraries for all sorts of domains.
Yet, it is also one of the most infamous roadblocks for Haskell
beginners, which this talk aims to address.

In order to build an intuition for what a Monad 'is' and especially for
how it's useful in everyday programming, we will take a look at several
important instances of the Monad class from the standard library (and
the de-facto standard transformers package): Maybe, Either, [], State
and IO. The examples will focus for the most part on how these very
different types are all instances of the abstract concept of a Monad,
and how using this abstraction and the associated syntactic sugar (do
notation) can lead to cleaner, more readable code. Afterwards, we will
take a look at how the Monad class is defined by a set of simple laws
that every Monad instance must obey. Time permitting, we may also touch
upon slightly more advanced topics such as Monad transformers and how
Monads are related to Functors and Applicative Functors.

Prerequisites: LYAH up to and including chapter 8 (or of course
anything else that covers the same topics). In particular, a basic
understanding of algebraic data types and type classes is essential.

Oliver Charles

Title: An Introduction to Web Programming

Abstract: For many people, Haskell is not their first programming language - a lot of us learnt to program in other languages like Python or Java, and would like to be able to use Haskell to solve practical problems. However, what seem to be simple web applications in other languages can be daunting to even begin using Haskell. In this talk, we'll look at how to build a small web application to allow ZuriHac participants to share what they have been working on. We'll use the Spock web framework along with postgresql-simple to build a basic CRUD application, and see how we can start prototyping a simple web application within minutes.

Gergely Risko

Title: Template Haskell

Abstract: Template Haskell is the meta programming extension for GHC. In this
talk we will investigate and livecode some basic concepts of code
generation and code introspection provided by this facility. We will
also take a look on an example: the hflags command line parsing
library.

Mathieu Boespflug

Title: Distributed Programming

Abstract: TBD

Johan Tibell

Title: Performance

Abstract: Production quality code not only needs to compute the correct result,
but needs to do so within some given resource constraints (i.e. time
and memory). We'll look at the most common optimizations you can use
to make your Haskell code perform better and some rules of thumb you
can use in your daily Haskell programming to avoid some performance
problems "by design".

Projects

Communication

If you have any questions before the event, please reach out to Alexander Bernauer <acopton@gmail.com> or Gleb Peregud <gleber.p@gmail.com>. If you are a confirmed participant, you will receive update emails from Alex as well.

Before the event, and in particular during the event, you can find us and other participants on irc://freenode.net/#zurihac. In addition, feel free to post on Twitter and Google+ using the hashtag #zurihac.