Join us for the 10th annual Haskell eXchange, a 3‑day online conference with content selected by developers for developers.
Over these 2 "Pro Track" days, you'll hear the latest from Haskell thought leaders, connect with fellow Haskellers in breakout sessions, and learn new skills in practical, coding-based talks.
Don’t miss this opportunity to learn and share your skills with the world’s most vibrant Haskell gathering.
Book today for only £99
NEW THIS YEAR!
If you've heard of Haskell or Functional Programming but aren't sure where to start, our new free "Novice Track" day is the perfect no-pressure way to learn about Haskell.
Register Here

The 2021 Haskell eXchange will be an online conference hosted on the Hopin platform.
At Skills Matter, we’ve chosen to see the events of the past year as a challenge to make our content and community more inclusive and accessible to all. Beyond the COVID‑19 pandemic, we have a vision of a community where knowledge sharing and skills transfer are not limited by physical barriers.
By hosting Haskell eXchange online in 2020, we were able to truly welcome a global community of Haskell enthusiasts and developers to the conference.
We are excited to be able to offer this opportunity again for 2021 and hope you can join us!
Who's going to be there?
This year's speakers include:
-
Simon Peyton Jones
keynote
"Provably correct, asymptotically efficient, higher-order reverse-mode automatic differentiation "
-
Nadia Polikarpova
keynote
"Generating Programs from Types"
-
Sukant Hajra
keynote
"Haskell: What To Do When Success Can't Be Avoided"
-
Alexey Kuleshevich
on
"Multi-dimensional Arrays that Do Not Exist"
-
Aravind Gopal Mallapureddy
on
"How We Migrated 65K Lines of Javascript Code to Haskell: Good, Bad and Ugly"
-
Csaba Hruska
on
"Why and how the external STG interpreter is useful"
-
Duncan Coutts
on
"Scaling Application State Beyond Memory: A Functional Approach"
-
Edsko de Vries
on
"Avoiding Quadratic Blow-up During Compilation"
-
Harendra Kumar
on
"Streamly: Haskell Programmer’s Swiss Army Knife"
-
Jacob Leach
on
"Designing and Verifying Programs with Formal Specification"
-
Krzysztof Gogolewski
on
"A Conceptual Introduction to Nix for Haskellers"
-
Luc Tielen
on
"Generating fast and expressive code using LLVM and Haskell"
-
Marcin Rzeźnicki
on
"A Curious Case of a Memory that Just Didn't Go Away Quickly"
-
Pepe Iborra
on
"Scaling up the IDE to 20M imports"
-
Sam Derbyshire
on
"An Overview of GHC's Constraint Solver"
-
Trevis Elser
on
"Haskell in the Enterprise: A Report from in the Belly of the Whale"
-
Utku Demir
on
"A tour of linear-base"
-
Xiaoyan Ren
Lightning Talk
"A Spectre is Haunting Haskell — The Spectre of Effects"
Explore Haskell eXchange 2021
Get involved, plan your conference, or start your learning today

View the program
Our 3-day online conference will feature experts and enthusiasts pushing the bounds of Haskell in both industry and academia.

Want to get involved?
Sponsoring a conference is a terrific way to support and connect with our global community of software professionals.
Learn More
Revisit 2020
View (or review) the 15 talks and sessions from Haskell eXchange 2020 in our library of SkillsCast videos.
Last year's conference featured memorable talks from the likes of Simon Peyton Jones, Mateusz Curylo, and Richard Eisenberg, plus the launch of the Haskell Foundation.
Diversity Matters Scholarship
Skills Matter offers scholarships to people from underrepresented groups in tech who wouldn't otherwise be able to attend.
If you believe you are a member of a group that is underrepresented within the tech community or at technical conferences we encourage you to apply.
Learn More
Program Committee
All of the talks at the Haskell eXchange are selected by our volunteer Program Committee which evaluates and selects which speakers and topics will be included in the conference program. This committee includes developers, practitioners and enthusiasts of all levels.
This year's Program Committee includes:
Excited? Share it!
Day 1: Haskell eXchange Pro Track
Haskell Day 2
Track | Main Track | |||
09:45
Invalid Time
Invalid Time
|
Opening Remarks/Housekeeping |
|||
10:00
Invalid Time
Invalid Time
|
KEYNOTE
Automatic differentiation is all the rage these days, largely because it is a key enabler for machine learning. But reverse-mode AD (the important kind) is a bit mind bending, and becomes much more so if you want reverse-mode AD for higher order programs (i.e. the kind we love). In this talk I’ll explain what AD is, and how we can do it for higher order programs, using a series of simple steps that take us a simple-and-obviously-correct version to a weird-but-very-efficient one. At the end of the road we’ll find the Kmett/Pearlmuttter/Siskind ‘ad’ library in Hackage… but I hope we’ll see it with new eyes. We are honoured to welcome back Simon Peyton Jones to the Haskell eXchange. Since the very first Haskell eXchange in 2012, we've been lucky to have Simon join us each year to share his unique perspective on everything from front end features to join points , Linear Types, and pattern matching — not to mention last year's very special announcement of the Haskell Foundation. Check out all of Simon's previous Haskell eXchange talks here.
machine-learning
automatic-differentiation
haskell
functional-programming
ghc
About the speaker...Simon Peyton JonesSimon Peyton Jones, MA, MBCS, CEng, graduated from Trinity College Cambridge in 1980. Simon was a key contributor to the design of the now-standard functional language Haskell, and is the lead designer of the widely-used Glasgow Haskell Compiler (GHC). He has written two textbooks about the implementation of functional languages. After two years in industry, he spent seven years as a lecturer at University College London, and nine years as a professor at Glasgow University before moving to Microsoft Research (Cambridge) in 1998. His main research interest is in functional programming languages, their implementation, and their application. He has led a succession of research projects focused around the design and implementation of production-quality functional-language systems for both uniprocessors and parallel machines. More generally, he is interested in language design, rich type systems, software component architectures, compiler technology, code generation, runtime systems, virtual machines, and garbage collection. He is particularly motivated by direct use of principled theory to practical language design and implementation -- that's one reason he loves functional programming so much. |
|||
11:00
Invalid Time
Invalid Time
|
In this talk Aravind will share his team's experience at Juspay, migrating a 65K line nodejs codebase to Haskell. He will take you through the entire journey of migration, parts where Haskell shines and also the not so good parts of Haskell. He will talk about : 1) Haskell as a preferred language choice 2) How we migrated 65K Lines of Code in just three months 3) Haskell Type System — A Super Power 4) Wins we got post migration — Extremely performant code, 100% more throughput per core 5) And just a few things we wish were better about Haskell This talk will give you insights and an unbiased view into what it takes to adopt Haskell at large scale, parts where Haskell is a super power and things to watch out for. |
|||
12:00
Invalid Time
Invalid Time
|
GHC's constraint solver is a notoriously difficult beast to understand, and there aren't many tools available to help us understand the process that GHC goes through while type-checking. In this talk, we will give an overview of how GHC generates constraints in the process of type-checking, and how it goes about categorising them and solving them. In particular, we will cover:
|
|||
13:00
Invalid Time
Invalid Time
|
The idea for the talk came from a series of performance investigations in which we tried to nail a bug that was causing unusually long pauses on our production machines. What was even more interesting was that the slowdown seemed to have quadratic characteristics, but all the GCs algorithms are certainly linear? It turns out that there are corner cases where this is not true. In fact, we have proposed a (accepted) bug report to GHC outlining this particular problem: https://gitlab.haskell.org/ghc/ghc/-/issues/19897 While these findings are interesting on its own, they would make a rather hermetic presentation. So instead of presenting the dry facts, the talk would turn towards topics that I believe to be valuable independent of a particular case: how to profile a misbehaving program and collect conclusive results pointing to the real cause; overview of existing GHC memory management tactics and data structures; general structures that can be used in memory management (trees, skip-lists) and their characteristics; how to hack on GHC to implement a new idea; how to use a hacked GHC.
haskell
bugs
memory
About the speaker...Marcin RzeźnickiMarcin Rzeźnicki is a programmer with close to 20 years of professional experience, mostly filled with immense displeasure of working in C#, Java or Ruby until I witnessed the advent of FP in the industry and regained the knowledge I'd lost leaving academia halls. Embracing Scala helped me to become born-again programmer, type system theorist and category theory hobbyist. I gave talks at meetups and conferences on subjects like: Kleisli arrows, dependent types and Free monads. I left Scala to devote myself to a clearly superior language: Haskell. |
|||
14:00
Invalid Time
Invalid Time
|
Break |
|||
15:00
Invalid Time
Invalid Time
|
||||
16:00
Invalid Time
Invalid Time
|
There are three main sources of of quadratic blow-up in the In this talk we will take a closer look at each of these problems. We will see how the |
|||
17:00
Invalid Time
Invalid Time
|
What is it like to bring Haskell to a large enterprise with an established culture? There are success stories for specialized teams, but what about the mainstream? We've been working in the trenches alongside enterprise developers doing Haskell for more than 3 years and have lots to report. This talk explores what it is like to use Haskell in an environment where the understanding and software engineering experience of developers is very mixed. Ranging from the Haskell language and the ecosystem around it, to how it has impacted the systems and people working with it, we will examine the journey from an introduction that took us into stormy seas and the vision of clear skies ahead.
haskell
experience-report
developer-experience
functional-programming
About the speaker...Trevis ElserTrevis works with teams writing real-world applications in Haskell as well as helping team members with little to no experience in the language get up to speed. His focus is delivering high-quality and maintainable systems using practical Haskell, along with other tools. Other interests of operating systems, security, choice, and usability, drive Trevis during spare time. |
|||
18:00
Invalid Time
Invalid Time
|
HLS is a popular Haskell IDE: fast, feature-rich, extensible, easy to install and ubiquitous. But what happens when you try to use it in a very large enterprise codebase? To understand the performance characteristics, we will deep dive into the ghcide build graph and execution model to characterise the amount of work done per keystroke. We will learn that currently the work is proportional to the number of import declarations and that this doesn't scale well. To address this issue we extend HLS to track the build nodes changed since last build and obtain a reactive build graph where the amount of work is proportional only to the number of nodes changed and their reverse dependency closure. HLS is an IDE engine built on top of a build system. The programming model is fantastic, and this talk shows that it also has an efficient execution model. Moreover, the talk will hopefully shed some light on the internals and serve as a resource for current and future HLS contributors. |
|||
19:00
Invalid Time
Invalid Time
|
KEYNOTE
Program synthesis is a promising approach to automating low-level aspects of programming by generating code from high-level declarative specifications. But what form should these specifications take? In this talk I will advocate for using types as input to program synthesis. Types are widely adopted by programmers, they can vary in expressiveness and capture both functional and non-functional properties, and finally, type checking is often fully automatic and compositional, which helps the synthesizer find the right program. I will describe two type-driven program synthesizers we developed. The first one is Synquid, a synthesizer for recursive functional programs that uses expressive refinement types as a specification mechanism. The second one is Hoogle+, which relies on more mainstream Haskell types and generates code snippets by composing functions from Haskell libraries. |
Day 2: Haskell eXchange Pro Track
Haskell Day 3
Track | Main Track | |||
09:45
Invalid Time
Invalid Time
|
Opening Remarks/Housekeeping |
|||
10:00
Invalid Time
Invalid Time
|
The first GHC version with the LinearTypes language extension is released early this year. This extension allows using linear arrows, where a function can specify how many times it uses its parameter. This seemingly minor ability opens up the door to many new abstractions; including, but not limited to, safe resource handling, pure mutable collections, and even the ability to manipulate values that are not managed by the garbage collector. There are many in-depth articles and talks about specific uses of
haskell
linear-base
linear-based
About the speaker...Utku DemirUtku has been using Haskell and functional programming professionally for more than seven years. Leaning more towards the practical use of the language, he is always fascinated to see PL research rapidly turning into useful tools in the Haskell ecosystem. He is also active in the open-source community; and as part of Tweag I/O, he has contributed to the |
|||
11:00
Invalid Time
Invalid Time
|
Streamly provides declarative combinators to express loops as a pipeline composed of modular building blocks. Each pipeline stage encapsulates a transformation over the data. Streamly makes it possible to compose concurrent programs declaratively. Data processing pipelines can be composed of concurrent actions and can run concurrently. Streamly unifies many functional abstractions; a small set of high-level combinators can express a wide variety of programming problems. Traditionally, you can write idiomatic programs that do not perform so well or high-performance programs that are not so idiomatic. Streamly provides both. This talk aims to introduce the library to a wider audience. We will go over the motivation for the library, how it is different from existing solutions, the abstractions it provides, key innovations, performance characteristics, and how to express some practical problems using the library. See more details at the streamly homepage. |
|||
12:00
Invalid Time
Invalid Time
|
Existing effect systems in Haskell all use one of two approaches: Free monad or effect typeclasses. As Alexis King pointed out in her talk in ZuriHac 2020, these two approaches are both unfriendly to compiler optimization because they all generalize too much, making neither effectful operations nor bind operations inlinable. A design pattern comes to rescue, the “phantom constraint pattern.” It works with effect typeclasses, in particular the ReaderT pattern. It allows users to write effectful code on a concrete monad, which is much more friendly to the optimizer than a free/polymorphic monad, while at the same time having the ability to control the use of effects via specific redundant constraints that contain no information. I will also talk about a work-in-progress effects library of mine, availability, that uses the said design pattern. I will give a comparison of its usage against other libraries and its design concerns.
haskell
effects
About the speaker...Xiaoyan RenXiaoyan Ren is a student who is enthusiastic about functional programming and PLT. She has written Haskell for 2 years and works with the awesome people at the PLCT Lab in ISRC, CAS building the Aya proof assistant. She loves to chat about dependent type theory and the implementation of type system elaboration. |
|||
12:30
Invalid Time
Invalid Time
|
Break |
|||
13:00
Invalid Time
Invalid Time
|
Nix is a package manager popular in the Haskell world, sharing many ideas with Haskell. In this talk, Krzysztof Gogolewski will explain Nix using Haskell as a basis. I assume basic knowledge of Haskell, but no knowledge of Nix. What is the novelty of Nix? Learning Nix and NixOS involves multiple jumps - the store, expressions, derivations, dependencies, packages, system configuration... Furthermore, as with any engineering project there's machinery that accounts for the messy reality. The talk is inspired by "Build Systems a la Carte" and "Nix pills", but they are not prerequisites. This will not be a tutorial on accomplishing specific tasks with Nix, but it should give enough background to prepare attendees for a deeper dive.
haskell
nix
functional-programming
About the speaker...Krzysztof GogolewskiKrzysztof is a software engineer at Tweag, working on linear types in GHC. |
|||
14:00
Invalid Time
Invalid Time
|
The goal of this talk is to explain delayed arrays, that are available in Immutable arrays in Haskell come with great safety properties and provide opportunities for a variety of optimizations. However, without fusion most operations on arrays do not compose efficiently due to intermediate allocations. Delayed arrays provide us with a reliable fusion framework, which is fully controlled by the user and guided by the type checker. Many operations on arrays are massively parallel, however the common Haskell technique of evaluating with
haskell
delayed-arrays
About the speaker...Alexey KuleshevichAlexey was born and raised in Belarus, and has lived most of his adult life in the USA and a bit in Poland. He has bachelor and master’s degrees in computer science from the University of New Mexico. Alexey has been coding in Haskell for almost a decade, including five years professionally at FP Complete and now at IOHK. Personal passion of writing efficient and safe Haskell has lead Alexey to creating a few open source libraries such as |
|||
15:00
Invalid Time
Invalid Time
|
In this talk, Luc will show how to create a language by making use of LLVM and Haskell. At the start, an introduction will be given on LLVM and the corresponding Haskell bindings. Afterwards, Luc will explain how techniques such as combinators and partial evaluation can be used to create performant functions optimized by LLVM. At the end, everything will be brought together and the result will be a small language that compiles all the way down to assembly. |
|||
16:00
Invalid Time
Invalid Time
|
Provided that data fits entirely within memory we can process data in an elegant way using classic Haskell techniques. Once we have more data than can fit in memory however we are often forced to abandon elegance to deal with mutable disk state in IO. While streaming style applications can often maintain an elegant pure core, it is particularly difficult to do so for transaction processing (OLTP) style applications which typically need random access to their data sets. The usual approach to building these applications involve using SQL or key-value databases and intermingling program logic with actions to fetch and change stored data. This talk explores an approach for OLTP style applications to scale to data sets bigger than fit in memory, while preserving a functional approach and the usual associated advantages. The approach uses ordinary pure functions that work over in-memory data structures, but nevertheless keeps the bulk of data on disk. The talk will explain the concepts and report on initial experience of applying the ideas in an existing commercial application. |
|||
17:00
Invalid Time
Invalid Time
|
Specifications languages have demonstrated themselves as an effective tool for designing and reasoning about complex software systems by capturing a high-level description of the system behavior in temporal logic. Declarative specifications of the intent of a system also serve models that can be checked in a fully automatic way, giving engineers formal guarantees on the correctness of their designs according to their specifications. In this talk, I will give an overview of Spectacle, a Haskell EDSL for writing formal specifications in the temporal logic of actions, and how specifications written in Spectacle can mechanically verify real-world Haskell programs.
haskell
edsl
specifications
spectacle
About the speaker...Jacob LeachI am interested in the design of functional programming languages, type systems, and program verification. |
|||
18:00
Invalid Time
Invalid Time
|
Many programming languages have a start with an academic foundation, but few languages carry such a deep sense of academic identity as they cross over into adoption in the industry. Haskell seems so different from the rest. SimSpace has been using Haskell at scale across nine teams, collectively maintaining over 400k lines of Haskell, developed over five years. We have a number of shared experiences and can speak to lessons learned over the years. This talk is an opportunity to share those experiences and give some helpful advice to others on a similar trajectory of using Haskell commercially. There's such a rich and historic narrative coming from the academic side of Haskell. This talk seeks to complement that narrative with an industrial perspective.
haskell
haskell-at-scale
haskell-in-industry
About the speaker...Sukant HajraSukant Hajra is a manager and team lead at SimSpace, a company providing a wide suite of products to assist enterprises with testing the security of their large-scale networks, as well as training and assessing of their security workforce. SimSpace uses Haskell heavily for a majority of their backend services, developed across nine cross-functional teams. Before that, Sukant wrangled machine learning code for a startup with Haskell and Nix, managed an FP-friendly data science team at Rackspace, and had a few jobs in the enterprise Java space. Somewhere in the middle of all that was a lot of Scala. Before programming for a living, Sukant had a prior career as a yield enhancement engineer in a variety of Motorola semiconductor factories. He has a BSEE and MSCS from The University of Texas at Austin, and also lives in Austin with his wife and dog. When not working, or dealing with worldwide pandemics, he likes to play a fretless electric bass that he's had since he was a much younger man. |
-
Keynote — Provably correct, asymptotically efficient, higher-order reverse-mode automatic differentiation
Featuring Simon Peyton Jones
Automatic differentiation is all the rage these days, largely because it is a key enabler for machine learning. In this talk I’ll explain what AD is, and how we can do it for higher order programs, using a series of simple steps that take us a simple-and-obviously-correct version to a...
machine-learning automatic-differentiation haskell functional-programming ghc -
How We Migrated 65K Lines of Javascript Code to Haskell: Good, Bad and Ugly
Featuring Aravind Gopal Mallapureddy
This is the story of how Aravind's team migrated their Javascript code into Haskell by implementing a transpiler and manually filling the voids in three months.
haskell nodejs migration javascript -
An Overview of GHC's Constraint Solver
Featuring Sam Derbyshire
GHC's constraint solver is notoriously difficult to understand, and there aren't many tools to help us understand the process that GHC goes through while type-checking. This talks is an overview of how GHC generates constraints in the process of type-checking, and how it goes about...
haskell type-checking ghc constraint-solver -
A Curious Case of a Memory that Just Didn't Go Away Quickly
Featuring Marcin Rzeźnicki
Sometimes a memory just lingers on, seemingly unable to leave you. For, say, 400 seconds. Dive deep into the curious workings of GHC GC and allocator and see for yourself. Warning: content contains explicit O(n^2) algori
haskell bugs memory -
Avoiding Quadratic Blow-up During Compilation
Featuring Edsko de Vries
There are three main sources of of quadratic blow-up in the
haskell quadratic-blow-up ghcghc
core code generated during compilation. This talk takes a close look at all three and how to deal with these problems with current-day GHC. -
Haskell in the Enterprise: A Report from in the Belly of the Whale
Featuring Trevis Elser
What's it like to bring Haskell to a large enterprise with an established culture? Using lessons learned over 3 years in the trenches alongside enterprise developers doing Haskell, this talk explores what it's like to use Haskell in an environment where understanding and experience is...
haskell experience-report developer-experience functional-programming -
Scaling up the IDE to 20M imports
Featuring Pepe Iborra
This is an experience report of how we made HLS work in a codebase with >30K Haskell modules and >20M import declarations.
haskell ide hls -
Keynote — Generating Programs from Types
Featuring Nadia Polikarpova
Program synthesis is a promising approach to automating low-level aspects of programming by generating code from high-level declarative specifications. But what form should these specifications take? In this talk Nadia Polikarpova will advocate for using types as input to program synthesis.
haskell smt types-systems program-synthesis -
A tour of linear-base
Featuring Utku Demir
linear-base, the base library for the new LinearTypes extension, comes with a variety of new abstractions. In this talk, Utku Demir of Tweag I/O offers a high-level overview of these abstractions; where are they useful and what they lack (for now).
haskell linear-base linear-based -
Streamly: Haskell Programmer’s Swiss Army Knife
Featuring Harendra Kumar
Streamly provides unified, declarative, and concurrent abstractions that are as simple as Haskell lists yet powerful enough to express a wide variety of practical programs idiomatically with high performance.
haskell streamly -
Lightning Talk: A Spectre is Haunting Haskell — The Spectre of Effects
Featuring Xiaoyan Ren
All existing effect systems have heavy performance penalty. Even mtl can betray you if you aren’t careful enough on specializing. But what if we can avoid all these — on a concrete monad with some redundant constraints?
haskell effects -
A Conceptual Introduction to Nix for Haskellers
Featuring Krzysztof Gogolewski
Nix is a package manager popular in the Haskell world, sharing many ideas with Haskell. In this talk, I will break down the essence of Nix and give you a conceptual model.
haskell nix functional-programming -
Multi-dimensional Arrays that Do Not Exist
Featuring Alexey Kuleshevich
This talk is about delayed computation techniques and their role in fusion, parallelization and stencil convolution, which are some of the core features in a high performance array processing library called massiv.
haskell delayed-arrays -
Generating fast and expressive code using LLVM and Haskell
Featuring Luc Tielen
In this talk, Luc Tielen will show how to create a language by making use of LLVM and Haskell.
haskell partial-evaluation combinators haskell-bindings llvm -
Scaling Application State Beyond Memory: A Functional Approach
Featuring Duncan Coutts
This talk presents techniques for transaction processing (OLTP) style applications to maintain a purely functional approach once we have to keep the bulk of our data on disk.
haskell application-state -
Designing and Verifying Programs with Formal Specification
Featuring Jacob Leach
In this talk, I will give an overview of Spectacle, a Haskell EDSL for writing formal specifications in the temporal logic of actions, and how specifications written in Spectacle can mechanically verify real-world Haskell programs.
haskell edsl specifications spectacle -
Keynote — Haskell: What To Do When Success Can't Be Avoided
Featuring Sukant Hajra
For 5+ years SimSpace has been using Haskell at scale across 9 teams, collectively maintaining over 400k lines of Haskell. In this talk Sukant will share some of these team's experiences, lessons learned and helpful advice to others on a similar trajectory of using Haskell commercially.
haskell haskell-at-scale haskell-in-industry
-
Haskell eXchange 2022: Online Conference
Two days - Online Conference
We're thrilled to once again welcome the global Haskell community to join the Haskell eXchange conference via our virtual conference platform, where across 2 jam-packed days, you'll connect with like-minded Haskellers and learn new skills through practical, coding-based sessions.
software-development haskell ghc functional-programming -
Haskell eXchange 2022: In-Person Conference
Two days in London
We're thrilled to once again welcome the Haskell community to CodeNode in London, where you'll meet hundreds of like-minded Haskellers face-to-face, discuss new technologies, and learn new skills through practical, coding-based sessions, as we explore what's new and what's next in...
software-development haskell -
Haskell eXchange 2022: Novice Track
One day - Online Conference
If you've heard of Haskell, but aren't sure where to begin, join us online 7 December for a day of free talks exploring the fundamentals of functional programming, the basics of Haskell, and answers to why teams use this increasingly popular language!
software-development functional-programming beginner haskell -
Haskell eXchange 2021: Novice Track
One day - Online Conference
This year at Haskell eXchange we've added a special "Novice Track" day for anyone who may have heard of Haskell, but isn't quite sure where to begin. Join us for a day of free talks exploring the fundamentals of functional programming, the basics of Haskell, and real-world uses...
haskell functional-programming -
Haskell eXchange 2020
Two days - Online Conference
The Haskell eXchange Online is the online edition of the annual conference created for and by the Skills Matter Haskell community. An opportunity for Haskellers to meet, learn and share skills, discover emerging technologies and help evolve the Haskell ecosystem.
haskell ghc functional-programming types haskellx -
Haskell eXchange 2019
Two days in London
Back for its eighth instalment, Haskell eXchange is an annual conference created for, and by, the Skills Matter community. An opportunity for Haskellers to meet, learn and share skills, discover emerging technologies and help evolve the Haskell ecosystem. Everyone is welcome to join, whether you...
nix monads cryptocurrency fp ghc haskell functional-programming types -
Haskell eXchange 2018
Two days in London
Back for a seventh installment, the Haskell eXchange is an annual conference created for and by the Skills Matter community. An opportunity for Haskellers to meet, learn and share skills, discover emerging technologies and help evolve the Haskell ecosystem. Everyone is welcome to join, whether...
haskell haskellx types functional-programming -
HaskellX2gether Community Weekend
Two days in London
Following up on the Haskell eXchange, we will hold a two-day Haskell eXchange Community Weekend - HaskellX2gether. Everyone is welcome, beginners and experts alike, and not just participants at the Haskell eXchange, but everyone who would like to participate in a two-day coding festival.
haskell haskellx hackathon hack functional-programming -
Haskell eXchange 2017
Two days in London
Back for a sixth installment, the Haskell eXchange is an annual conference created for and by the Skills Matter community. An opportunity for Haskellers to meet, learn and share skills, discover emerging technologies and help evolve the Haskell ecosystem. Everyone is welcome to join, whether you...
haskell haskellx types functional-programming -
Haskell eXchange 2016
Two days in London
In its fifth year, the Haskell eXchange is an annual conference created for and by the Skills Matter community. An opportunity for Haskellers to meet, learn and share skills, discover emerging technologies and help evolve the Haskell ecosystem. Everyone is welcome to join, whether you are an...
types monads functional-programming haskell haskellx -
Haskell Infrastructure Hackathon 2015
Two days in London
Following up on the Haskell eXchange, we will hold a two-day Haskell Hackathon at Pivotal. Everyone is welcome, beginners and experts alike, and not just participants at the Haskell eXchange, but everyone who would like to participate in a two-day coding festival.
haskell haskellx functional-programming monads types -
Haskell eXchange 2015
Two days in London
Want to learn about the latest innovations in Haskell? Join 100+ functional programmers to learn modern approaches as well as how Haskell's application in enterprise is changing the way our industry tackles complex engineering problems.
haskellx haskell functional-programming monads types -
Haskell eXchange 2014
One day in London
Want to join the dots of the Haskell landscape? Eager to hear from those driving innovations in Haskell in various industry and academic fields? Then join Haskell experts and enthusiasts this October for London's premier Haskell conference.
haskell functional-programming monads types -
Haskell eXchange 2013
One day in London
The second edition of the Haskell eXchange returns to Skills Matter HQ on October 9th. This unique and dedicated Haskell event will pull together Haskell enthusiasts, developers, and thought leaders across Europe.
haskell clojure akka functional-programming haskellx -
Haskell eXchange 2012
One day in London
Skills Matter is proud to announce the first annual Haskell eXchange. While we're working with Neil Mitchell to put together a fantastic programme for you, we can already tell you that Simon Peyton-Jones is confirmed to make a keynote!
For updates on the latest presentations and speakers,...
haskell