During this talk, you will learn how to use Haskell's powerful features for abstraction to create a Neural Network library in native Haskell that makes it easy to create complex network architectures in a type-safe and flexible way. Automatic differentiation is used to provide painless gradient descent and easy extension with new components without the need to first compute complicated partial derivatives by hand. Furthermore, the API uses "Pipes" for separation of concerns (data import, training, reporting, termination).

About the speaker...

Lars Brünjes

Lars is a pure mathematician by training, and holds a PhD in the same. He has spent several years teaching and doing postgraduate research in arithmetic number theory at Cambridge University in the UK, and at Regensburg University in Germany. He worked for ten years as a Lead Software Architect for an international IT company. His job, amongst other things, was the application of mathematical optimization techniques to the paper industry and web framework development (using mostly C#, JavaScript and TypeScript). His present position is that of Director of Education at Input Output Hong Kong (IOHK), working on blockchain technology and teaching Haskell and other subjects. He has been interested in programming since his early teens, and he loves learning new programming languages and paradigms - in particular those that offer a radically new way of looking at problems and of thinking about solutions. He is especially fascinated by functional programming and its promise of elegant, bug-free code that can be developed rapidly.

Many Haskell programmers write parsers using parser combinator libraries like `parsec` or `uu-lib`, or parser generators like `happy`. These systems are popular because they are easy to get started with and suitable for production applications. In particular, parser combinators libraries are popular because the parsers obtained in this way are easy to debug, maintain, generalise and compose. The disadvantages of the underlying parsing technologies - left-recursion, nondeterminism and ambiguity - are well understood and can be circumnavigated. Some argue that parsing is therefore a solved problem. Others turn to generalised parsing. Generalised parsing overcomes these disadvantages: modern parser generators are capable of generating parsers for arbitrary context-free grammars. The generated parsers find all possible derivations of an input string in worst-case cubic time and space. In recent years, combinator libraries like `p3` (OCaml) and `meerkat` (Scala) emerged, promising to combine the advantages of parser combinators with those of generalised parsing. In this talk, you will explore the implementation of the `gll` combinator library, offering generalised top-down parsing to Haskell programmers. The combinators of these libraries are so powerful that they may compute explicit representations of context-free grammars, enabling features common to parser generators like lookahead tests and grammar transformations. This power comes at a price. Following the authors of the `grammar-combinators` library, I argue that combinator libraries for generalised parsing require observable sharing. As a consequence, such combinator libraries cannot offer programmers the same flexibility as `parsec` and `uu-lib`. Although offering generalised parsing, some benefits of combinator parsing are definitely lost.

In this talk, - You learn the basics of combinator based parsing in Haskell - You are introduced to generalised parsing - You get a glimpse of the gll combinator library you can find on Hackage

About the speaker...

Thomas van Binsbergen

L. Thomas van Binsbergen is a PhD student in Computer Science at Royal Holloway, University of London, and an MSc graduate of Utrecht University. His work revolves around the specificying and prototyping programming languages. Notable are the contributions he made to the Utrecht University Attribute Grammar Compiler (UUAGC), implementing algorithms for compile-time scheduling of attribute evaluation based on dependency analysis. In recent years, Thomas has been associated with the PLanCompS project and has developed Haskell tools for defining and executing FunCons: highly reusable and modular components used in the formal specification of programming languages' semantics.

In this hands on tutorial, you will build a simple Haskell application: a bot that does things on reddit.com (for example, highlighting posts that match certain rules) by driving reddit's API from a Haskell application.

You will explore a selection of practical topics that are useful when using Haskell in the real world, for example: monad transformer stacks for configuration and logging, parsing JSON, using lenses, and error handling.

It would be great if you could program well in some other language, and have basic Haskell knowledge (for example: what functions and types are, what map does). You will also need to bring a laptop along with stack configured ahead of time, and will need a network connection.

More info on how to configure stack can be found here.

About the speaker...

Ben Clifford

Ben's career has spanned supercomputing, distributed systems, and programming languages, and taken him all across the world from Los Angeles to Johannesburg. Most recently he has been based in London taking Haskell work where he can find it.

Ling is an experimental programming language combining the precision of a system-level programming language and the abstraction and safety of a pure, functional programming language.

This combination is made possible by the underlying theory which is based on a combination of dependent type theory and linear logic. In practice, this provides a general form of program fusion (an optimization short-cutting production and consumption of data) which is part of the type system, and which can still be finely controlled.

In Ling, resource allocations such as memory are explicit. Fusion may happen at each allocation point. The user controls how much fusion should happen, and the type system checks if this is possible. The resulting fusion framework is both quite general and fully predictable.

About the speaker...

Nicolas Pouillard

Nicolas's current areas of research/interests are a mixture of Functional programming/Type Theory and Cryptography/Security.

He is currently working for Liqd.net on the AuLa project (open source and written in Haskell) aiming at bringing liquid democracy to students.

Previously, he was a postdoc researcher with the Demtech project at IT Univeristy of Copenhagen focusing on formalizing cryptographic voting protoctols in type theory.

Before that, he was an engineer and then a PhD student in the Gallium research team at INRIA Paris Rocquencourt. At that time, he was mainly focused on the design of programming languages and in particular meta-programming.

He learned programming and computer science at the engineering school of EPITA in Paris.

Nicolas tweets at @npouillard, and his website can be found at https://nicolaspouillard.fr.

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. In this talk, you will learn that 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. You will use functional programming to design abstractions for build systems and overcome these challenges. You will explore 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.

About the speaker...

Andrey Mokhov

Andrey Mokhov is a senior lecturer in computer engineering at Newcastle University and a Royal Society Industry Fellow.

He is interested in applying abstract mathematics and functional programming to industrial engineering problems. In 2015 he was a visiting researcher at Microsoft Research Cambridge redesigning the build system of the Glasgow Haskell Compiler; this project is currently continued as part of a 4-year Royal Society research fellowship dedicated to studying build systems in general.

In this hands on tutorial, you will build a simple Haskell application: a bot that does things on reddit.com (for example, highlighting posts that match certain rules) by driving reddit's API from a Haskell application.

You will explore a selection of practical topics that are useful when using Haskell in the real world, for example: monad transformer stacks for configuration and logging, parsing JSON, using lenses, and error handling.

It would be great if you could program well in some other language, and have basic Haskell knowledge (for example: what functions and types are, what map does). You will also need to bring a laptop along with stack configured ahead of time, and will need a network connection.

More info on how to configure stack can be found here.

About the speaker...

Ben Clifford

Ben's career has spanned supercomputing, distributed systems, and programming languages, and taken him all across the world from Los Angeles to Johannesburg. Most recently he has been based in London taking Haskell work where he can find it.

Haskell is a lazy language and thus differs from most other widely used languages. The way that Haskell programs are executed can be obscure to newcomers and old hands alike. It's not actually too hard to understand how Haskell programs are executed, but it is rather unusual! This talk will demystify lazy evaluation and help explain related issues such as performance and space leaks. The talk will be accessible to beginners but should be interesting to Haskellers at any point on the experience spectrum!

About the speaker...

Tom Ellis

Tom Ellis studied computer science and mathematics at the University of Cambridge, graduating with a PhD. Since then he has worked as a software developer in the finance sector, mainly as a consultant using Haskell. He is the author of the Haskell "Opaleye" library for type-safe, composable Postgres access, and is an experienced public speaker.

In this talk, you will discover that broad language interoperability is crucial for Haskell's success in not entirely insignificant niches such as the enterprise. And that performance of language binding mechanisms is the key to retaining good modularity. Hot on the heals of previous efforts such as inline-c and inline-r, you will learn inline-java and explore how the library enables you to ask existing JVM-based frameworks to seamlessly distribute your analytics Haskell apps at scale on dozens of machines in the cloud.

About the speaker...

Mathieu Boespflug

Mathieu Boespflug is a functional programmer and enthusiast based in Paris. He is the founder of Tweag I/O, an R&D Lab pushing the practice of programming language theory and distributed systems. Some time before that, after having learned Haskell from the venerable old and new guard at the University of York, he wrote Haskell and Ocaml at various academic institutions, focusing on compiler technologies for dependent types during his PhD (École Polytechnique, France) and type safe metaprogramming for both proofs and programs during his postdoc (McGill, Canada).

Thanks to recent work by Bas and Roel van Dijk at Lumiguide, it is now possible and easy to use OpenCV from Haskell. In this talk, you will discover how Haskell lets us define a typed and ergonomic API on top of the OpenCV types and functions, and how easy it is to define new bindings -- also thanks to the inline-c library presented at last year Haskell eXchange. Following this, you will explore the full capabilities of the bindings through a live coding demo showing how you can process input from a webcam in real time.

About the speaker...

Francesco Mazzoli

Francesco Mazzoli is a Haskell programmer working at FPComplete from Rome. Before that, he has dropped out of a PhD working on Agda, worked with Haskell at Better, and spent almost a year working at RabbitMQ. He studied Computer Science at Imperial College London.

Confused by foldl' vs foldl? Unsure when you've got the strictness right? Programs taking too much memory and running too slow? You are not alone! Most Haskell programs suffer from "space leaks" - this talk covers examples (all only found and fixed in the last year) from the base library, QuickCheck, pretty, Happy, Alex and Shake. Some fixes saved over 1Gb of memory! Space leaks occur when a program uses more memory than necessary. Haskell, as a lazy language, is particularly vulnerable to a form of space leak where a small accumulator (e.g. an Int) is instead represented by a sequence of updates that grows on each iteration. In this talk, you will learn the gritty details of space leaks, then the session sets off on a quest to remove them from all Haskell programs. You will explore the relationship between space leaks and stack usage, then how to use the existing tools built in to GHC to detect and debug excessive stack usage. These techniques have already slain lots of space leaks, and hopefully in your hands they can destroy even more.

About the speaker...

Neil Mitchell

Neil Mitchell is a Haskell programmer who lives in Cambridge with his wife Emily and his son Henry. Neil has a PhD in Computer Science from York University, working on making functional programs shorter, faster and safer. Since then he's worked with F# at Credit Suisse and Haskell/F#/C++ at Standard Chartered and Barclays, taking the lessons of functional programming and applying them in finance.

Neil is a strong believer in the functional approach, finding the combination of conciseness, static-typing and testability to offer significant advantages. He is currently developing a number of open source Haskell projects, all of which can be found on his Github page or on Hackage. He welcomes both contributions via pull requests and bug reports via the GitHub issue trackers. Some of my more popular projects include:

• Shake - a library for writing build systems, an alternative to make.
• Hoogle - a Haskell API search engine, searching the standard Haskell libraries by function name and type signature.
• HLint - a tool that suggests stylistic improvements to Haskell code.

Check out Neil's blog and follow him on Twitter @ndm_haskell.

In this talk, you will explore using QuickCheck and using it beyond technical tests or for testing algebraic properties & visual symmetries: You will dive into the rich world of Business Domain Specific properties! See that your business rules are Domain Invariants (in the DDD sense), and you will learn how to translate them to properties QuickCheck can check!

About the speaker...

Romeu Moura

Writer of tales – on art, puzzles & crafts – to friends & compilers. Likes dialectics, paradigm jumping, serendipity, endless conversations.

In this talk, you will explore a case study on how to implement a 3D first person shooter game in Haskell. The project's goal is to mimic the Quake 3 engine, but starting from scratch using purely functional paradigm. You will discover each problem domain related to a 3D engine and game, such as loading and displaying the game content, game logic implementation.

Luckily, you can learn to use off the shelf solutions from the Haskell ecosystem as a solution (e.g. binary, megaparsec, monad transformers, lens, lambdacube 3D).

Find out more on lambdacube here.

About the speaker...

Csaba Hruska

Csaba is an enthusiastic Haskell programmer with interest in compilers, graphics programming and game development.

He likes to experiment with cutting edge technologies usually doing it in open source collaboration.

Csaba's projects typically combine multiple fields from his interest. i.e.

• LambdaCube 3D, a pure functional domain specific language for computer graphics
• Quake 3 map viewer / game engine in Haskell using LambdaCube 3D
• GRIN, a compiler back-end for lazy functional languages with whole program optimisation support (https://github.com/grin-tech/grin)

Csaba tweets at @csaba_hruska.

The STG is the lowest functional intermediate representation of GHC-Haskell, and the gateway between the functional world and the metal. At this level, many common questions are answered, such as when stack and heap are accessed, why space leaks happen, or why certain algorithms are surprisingly inefficient.

With this talk, you will discover into the operational semantics of Haskell, by executing a couple of small programs everyone should be
familiar with, and watching what happens to stack and heap during execution, such as in the classical foldl (+) 0 overflow.

About the speaker...

David Luposchainsky

David has been a Haskell enthusiast ever since he (was) stumbled upon it in early 2012 as a physics student. After spending a lot of time with it and talking to others in #haskell, he proposed the unifying the Applicative-Monad hierarchy and removing the fail function from the Monad class to the mailing lists. The former is live as of GHC 7.8, the latter is in a backwards-compatible slow transitional phase for the next couple of compiler versions. As of 2016, he is member of the Core Language committee to work on the next Haskell standard.

When David isn't working or haskelling, he spends his time outdoors hiking, bouldering, mountainbiking or motorcycling.

There are several powerful mechanisms for testing applications in the servant ecosystem that are not yet widely known or documented. You will explore them, showing how you can state, sometimes as type constraints, sometimes as QuickCheck predicates, properties about entire applications, such as:

• No endpoint returns a 500 HTTP error
• No endpoint returns a 'Password' datatype.
• Application A and application B behave in the same way
• No request takes longer than 50 ms.

These techniques largely apply (though not as cleanly) to web applications written with frameworks other than servant-server - indeed, written in any language. During this talk, you may also discover how the servant ecosystem can be used to improve integration tests. Among the packages you will look at are servant-quickcheck and servant-mock. Prior experience with servant is not required.

About the speaker...

Julian Arni

Julian K. Arni is a Haskell consultant, founder of Turing Jump, and one of the original authors of servant.

Haskell programs make use of overloading extensively. As a consequence, qualified types, i.e., types containing class constraints are ubiquitous. In this talk, you will discover how a type system with type classes works internally, and how a compiler such as GHC deals with the presence of qualified types. You will explore the basics of the "dictionary translation", and how it is applied during type checking.

If you are a Haskell beginner who would like to learn more about how the Haskell type system works, this talk is for you! You would also have lots to learn if you are more advanced in the language.

About the speaker...

Andres Löh

Andres Löh is a Haskell consultant and co-owner of Well-Typed LLP. He is based in Regensburg, Germany. He started using Haskell in 1997, when being an undergraduate student of mathematics in Konstanz and has been an enthusiastic functional programmer ever since. Andres obtained a PhD in Computer Science from Utrecht University in 2004, on extending the Haskell language with capabilities for datatype-generic programming. After having been a university lecturer for several years, he joined Well-Typed in 2010.

Andres is very interested in applying functional programming to real-world problems, and in particular in datatype-generic programming, domain-specific languages, (dependent) type systems, parallel and concurrent programming, and the theory of version control.

The talk will focus on how to restrict effects performed by monadic computations using type classes. You will explore the pros and cons of this approach in relation to its alternatives as well as how to solve several common issues that arise, such as the problem of quadratic number of instance definitions.

About the speaker...

Andrzej Rybczak

Andrzej Rybczak has been using Haskell in production since 2011. He also studied Computer Science at Wroclaw University of Technology and Mathematics at University of Wroclaw.

Join Bas for a great talk on Functional Programming!

About the speaker...

Bas van Dijk

Bas is a CTO at LumiGuide.

Bas previously worked as a Software Engineer for Erudify and a Haskell Hacker for Sensor Sense (Nijmegen, The Netherlands.

Introducing the Haskell-tools refactoring framework for Haskell. The system provides opportunities to easily write new refactorings thanks to its purely AST-based approach.

About the speaker...

Boldizsár Németh

Researcher from Eötvös Loránd University.

Worked on projects ranging from functional programming to assembly programing. Holds lectures on Java and Compilers. Has interest in domain specific languages, modeling and development of programming tools.

Find out more on Boldizsar project here.

In this talk, Robin will use the medium of building a playable Haskell clone of the classic computer game "Pipe Mania" to show how typed functional programming can be applied to create effective domain models and work with them.

You will begin by learning how algebraic data types can model our game and give you control over the size and shape of state spaces. Furthermore, that there are trade-offs between different models and that the best model can vary depending on the task at hand.

Hence, you will explore two separate models suited to implementing different parts of the game program and learn how to work with and translate between these models, starting with simple primitives and building up to implementing the complete game. Finally, the talk concludes by building a view for our model using the HsQML GUI framework in order to make a fully playable and complete application."

About the speaker...

Robin Kay

A long-time Haskell hobbyist, Robin KAY currently works professionally as an F# developer in the finance sector.

In web development, a great deal of effort is spent on consistency. The frontend, backend and database must all agree on a data-model, and if they don’t, the system crashes spectacularly.

The default solutions are either to invest heavily in hand-written integration tests, or use JavaScript everywhere. Neither of these are ideal. However there is a compelling alternative - use the same types everywhere. By reusing strong, static types across tiers, you can make guarantees about the consistency of the entire system, and dramatically lower the cost of change.

In this talk, you will explore one approach that uses Haskell data types to drive a both a PostgreSQL database schema and a frontend system written in Elm. With one set of types to rule them all, whole system consistency is automatic and reliable, and the cost of changing types - and hence evolving the whole system’s data model - is dramatically reduced.

About the speaker...

Kris Jenkins

Kris Jenkins is a successful startup cofounder, turned freelance functional programmer, and open-source enthusiast. He mostly works building systems in Elm, Haskell & Clojure, improving the world one project at a time.

Introducing the Haskell-tools refactoring framework for Haskell. The system provides opportunities to easily write new refactorings thanks to its purely AST-based approach.

About the speaker...

Boldizsár Németh

Researcher from Eötvös Loránd University.

Worked on projects ranging from functional programming to assembly programing. Holds lectures on Java and Compilers. Has interest in domain specific languages, modeling and development of programming tools.

Find out more on Boldizsar project here.

In this talk, you will discover how Jeremy and team designed the learning materials for a massive open online course about Haskell, and what they found to be most effective techniques for engaging novice Haskell developers.

About the speaker...

Jeremy Singer

Jeremy is a lecturer in Computing Science at the University of Glasgow. He is moderately fluent in the following languages: Haskell, Java, C, Scouse and New Testament Greek.

Jeremy tweets at @jsinger_compsci.

This talk introduces string diagrams as a notation for calculating in category theory. You will learn the diagrams to better understand monads, adjunctions, and finally free monads. All of this, of course, is relevant to the curious Haskell programmer who wants to better understand abstract nonsense.

About the speaker...

Nicolas Wu

Nick has been using Haskell since 2001 while he was an undergraduate at the University of Oxford, where he also obtained his doctorate in Computer Science. He then went to work as a Haskell consultant at Well-Typed LLP before returning to academia. As a postdoctoral researcher he worked principally on unifying the foundations of recursion schemes using category theory. He is currently a lecturer at the University of Bristol, and continues to work on recursion schemes, as well as effect handlers and domain specific languages.

CλaSH (pronounced ‘clash’) is a functional hardware description language that borrows both its syntax and semantics from the functional programming language Haskell.

This is just a fancy way of saying that CλaSH is a compiler for Haskell, but instead of creating machine code (like GHC), or javascript (like GHCjs), CλaSH generates digital circuits (in the form of VHDL or Verilog code).

In this talk, you will learn the use of CλaSH to create your own digital circuits in Haskell, and how you can use the generated HDL code to program FPGAs.

About the speaker...

Christiaan Baaij

Christiaan Baaij has been programming in Haskell since 2009, when he started on the first prototype of the CλaSH compiler. Since then, he is always keen on trying to figure out ways to effectively use GHCs latest language extensions for doing circuit design in Haskell. After obtaining his PhD in 2015 from the University of Twente he continued to work on the CλaSH compiler and has recently co-founded QBayLogic to bring the use of CλaSH to industry.

Christiaan tweets at @ChristiaanBaaij.

Matthias Fischmann and Andor Penzes - Building web application with servant, lucid, and digestive-functors

Jann Mueller - Virtual-Hom - Lenses & Prisms for the user interface

Steven Kutsch - Commonsense Reasoning using Haskell

About the speakers...

Matthias Fischmann

Matthias is a software developer and consultant. Exclusive focus on Haskell since 2015.

Degrees from Max-Planck Institute of Computer Science in Saarbrücken, Germany and Humboldt-University Berlin, Germany. Projects besides Aula include an identity management proxy, a servant-inspired configuration library, a toolkit for reverse-engineering and optimizing SAP analytics databases, and a framework for testing both the REST interfaces and the UI of web applications in an integrated test API.

Andor Penzes

Andor is a Haskell developer and enthusiast, interested in theoretical computer science, he has industrial experience with functional and object oriented programming, QA engineering, learns dependently typed programming and playing the hangdrum. Andor has recently revived his interest in compiler construction.

Jann Mueller

Jann is a computer scientist and programmer. He is a Ph.D. candidate at University College London, where he publishes on Artificial Intelligence. He is currently working for Sphonic, a London-based startup, developing smart tools to fight fraud. Prior to that, Jann was at SAP Research where he thought up new techniques for handling inconsistencies in design documentation. He is a passionate advocate of functional programming, whether it is in Scala at work or in Haskell and Agda at home.

Steven Kutsch

Steven has a Master of Computer Science at the Trier University of Applied Sciences and is currently a Research assistant at the University of Hagen in the area of knowledge based systems.

Csongor Kiss - Generating Elm data types using GHC Generics

Philip Cunningham - i18n for Haskell Web Applications

Robert Henderson - Graphics, sound, fonts, and joysticks unleashed: the Junpi multimedia library

About the speakers...

Csongor Kiss

Haskell enthusiast.

Philip Cunningham

Philip is a web application developer working in Haskell, JavaScript, PureScript and Ruby.

Robert Henderson

Robert Henderson founded the company Fivey Software in 2015 with the following dual mission: to create commercial video games in Haskell, and to develop high-quality free / open-source game-making tools for the Haskell language. Fivey Software's first game is scheduled for release on Raspberry Pi and PC in 2017.

Robert's website is https://fiveysoftware.com/.

Michał Płachta - Purely Functional Web Apps with Servant and Elm

Nickolay Kudasov - Real World Servant: GetShopTV experience report

Oleg Grenrus - PVP considered harmful... NOT

About the speakers...

Nickolay Kudasov

Nickolay is the CTO & co-founder at GetShop.TV and a Haskell teacher at Moscow State University.

He has been a Haskell enthusiast since 2009 and is an author and maintainer of some Hackage packages.

GitHub profile

GetShopTV GitHub organisation

Nickolay tweets at @crazy_fizruk.

Oleg Grenrus

Oleg is a programmer from Finland (i.e. he's a humble person). He became active in the Haskell community around 2015, and nowadays co-maintains (among other things) servant web-framework, the one where type trickery is involved.

Michał Płachta

Polyglot software engineer specialised in developing distributed applications. Functional programming enthusiast. Loves the human component in software projects. Drinks a lot of tea. Has a blog at michalplachta.com. He currently works as team leader at Ocado Technology, where he is building actor-based software for automated warehouses.