|Friday 22th of July 2016 - Sunday 24th of July 2016
|Google, Zurich, Switzerland
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 event is open to any experience level, from beginners to gurus. In fact, one of the goals is to bring beginners in contact with experts so that the former can get a quick start in the Haskell community. We will have a dedicated beginners' track, and there are going to be mentors on site whom you can directly approach during the whole event with any Haskell-related question that might pop up.
Google Switzerland hosts the Hackathon.
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.
Unfortunately we have reached our maximum capacity. If you want to be queued into the wait list please still fill out this form. In case that somebody cancels we will fill up the seats from the wait list in first come first serve order and let you know. Do not book anything before we have confirmed a seat for you (in a second confirmation email) though.
Here is the list of participants who have signed up for ZuriHac 2016 and have chosen their name to be listed there.
Here is a map with map with all important locations.
See here for public transport in the Zurich area.
A note on day tickets:
Day tickets in Zurich run for 24 hours and can be used on all forms of transport in zone 110 that is bus, train, tram or even ship.
If you arrive via airplane, please note that the airport is outside of the zone 110, which only covers the city of Zurich itself. So you need to upgrade your ticket to include for the time of your travel into the city (around 15 min) one additional zone.
You can buy tickets from the ticket machines.
|Welcome & Project Introduction
|Edward Kmett, Monad Homomorphisms (Key Note)
|Andres Löh, Generic (and type-level) programming with Generics-Sop (Key Note)
|Bas van Dijk, FP at LumiGuide (slides) (Key Note)
|Andrey Mokhov, Meet Hadrian: a new build system for GHC (Talk)
|Project Presentation & Closing
|David Luposchainsky, Low-level Haskell: an interactive tour through the STG (Talk)
|Francesco Mazzoli, Parallelizing and distributing scientific software in Haskell (Talk)
|Luka Rahne, CλaSH - Programming FPGA in Haskell(Talk)
|Alexander Thiemann, Spock - Powerful Elegant Web Applications (Talk)
|enjoy the city or continue coding until 10pm
|--> BBQ <--
The links to the slides of the talks can be found on the HaskellerZ github page.
Title: Spock - Powerful Elegant Web Applications
Abstract: This talk will give an insight on web development using the Haskell web framework «Spock» ( https://www.spock.li ). It will give a short overview of the possibilities like type-safe routing, hyperlinks, sessions, database queries, templates and JSON parsing/generation and then we will also look at a technique to build a full stack application with Spock and GHCJS as used in production in TramCloud.
Title: Generic (and type-level) programming with generics-sop
Abstract: Many Haskell functions can be defined for a large class of datatypes in a systematic way. Examples include structural equality and comparisons, all kind of (de)serialization functions (plain text, JSON, binary, etc.), traversal and access functions such as lenses and their various variants, functions for querying and updating databases and many more. For some built-in type classes, Haskell offers the "deriving" construct, but GHC also has a "generics" feature that allows users to define their own derivable classes, without having to resort to Template Haskell.
In this talk, I'm going to introduce "generics-sop", a library that supports such datatype-generic programming by means of a number of powerful, higher-order combinators that can be reused and composed in several ways. This approach makes use of several type-system extensions available for GHC, such as GADTs (in particular, for heterogeneous lists), data kinds, kind polymorphism, constraint kinds, and rank-n polymorphism. We will start from examples and see how we can define a few generic functions using generics-sop and then, as far as time permits, look more closely at how it all works.
Title: Meet Hadrian: a new build system for GHC
Abstract: Most build systems start small and simple, but over time grow into hairy monsters that few dare to touch. Our favourite Glasgow Haskell Compiler is no exception. As we'll see in this talk, there are a few issues that cause build systems major scalability challenges, and many pervasively used build systems (e.g. Make) do not scale well.
We use functional programming to design abstractions for build systems and overcome these challenges. I'll introduce a new build system for GHC, called Hadrian, that we engineered using these abstractions. The result is more scalable, faster, and spectacularly more maintainable than its Make-based predecessor.
You can find more details in this paper: https://www.staff.ncl.ac.uk/andrey.mokhov/Hadrian.pdf
Hadrian is still under active development: https://github.com/snowleopard/hadrian
Bas van Dijk
Title: Functional Programming at LumiGuide
Abstract: I will give an introduction to LumiGuide and talk about how we use Haskell to build our bicycle detection and guidance systems. The first part of the talk will be non-technical but in the second part I will dive deep into haskell-opencv: a Haskell to OpenCV 3.1 binding that we recently open sourced. Roel van Dijk and I will do a live coding session showing how to bind a function from OpenCV to Haskell. Along the way we demonstrate the use of the inline-c library, describe how we handle C++ exceptions and show how we are using advanced type system features to encode more information into the type of matrices.
Title: Low-level Haskell: an interactive tour through the STG
Abstract: Executing lazy functional programs is often met with suspicion, as something processors somehow don't do “naturally”. In this talk, I will show just how wrong such statements are.
We will take a tour through a few well-known Haskell programs in their STG representation. STG is a tiny functional language used in GHC's compiler backend. What makes STG particularly interesting is it is feels close to both Haskell and the metal, and allows us to watch how Haskell programs are executed step-by-step.
Why does `foldl (+) 0` overflow, and is it the stack or the heap? How are things pushed onto the stack or allocated on the heap anyway, and what cleans them up again? How does laziness work? Why are unboxed values often faster, how does a list look like in memory, how efficient is the popular Quicksort-inspired example algorithm really?
The goal of the talk is to introduce the audience into the operational semantics of Haskell, by executing a couple of small programs everyone should be familiar with, and discussing what happens during execution. The topic is suitable for audiences of all skill levels.
Title: Monad Homomorphisms
Abstract: The way that we use the monad transformer library today leads to code that has pathological performance problems. Can we do better?
Title: Parallelizing and distributing scientific software in Haskell
Abstract: Suppose you have a pure, CPU intensive function that you need to run on 10000 different inputs. This seems the dream task to parallelize in Haskell, but as it turns out it is not as easy as one might think. In this talk I'll describe what we needed to do to parallelize such an application on machines with as many as 18 cores, and further what we needed to do to distributed the same application across separate machines, on hundreds of cores.
Title: Clash - Programming FPGA in Haskell
Abstract: Clash is compiler and programming language, that transform Haskell like language into description of digital circuit aiming for both FPGA and ASIC. Tools from Haskell ecosystem including libraries and GHC features can be used to make reliable and efficient hardware. Basics of FPGA and digital circuits design will be presented and also how Clash can be used to describe, simulate and synthesize such circuits.
Haskell Mentors and the ZuriHac Codelabs
We want to support Haskellers at all levels, which is why we provide both dedicated Haskell mentors and a dedicated Haskell codelab.
Haskell mentors wear a black ZuriHac mentor shirt; and they welcome all your questions. So please just fire away and make them work ;-)
Mentors can find the schedule here.
The memegen codelab is available on GitHub. It guides you step by step through the implementation of a memegen server in Haskell. Its intended audience are people that want to learn more about writing web application servers in Haskell. The mentors are available to help you with any problems that you might encounter.
A second codelab is in preparation. See the webwatch lab for more information.
See the projects page.
If you have any questions before the event, please reach out to Alexander Bernauer <firstname.lastname@example.org>.
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 #ZuriHac2016.
The events are organized in name of the Zurich Haskell meetup group by the following people:
- Gleb Peregud (Google)
- Alexander Bernauer (Digital Asset)
- Simon Meier (Digital Asset)
- Ivan Kristo (Google)
- Jasper Van der Jeugt (Luminal)
- Arvin Moezzi (Google)