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.
Simon 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.
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.
Nadia Polikarpova is an assistant professor at UC San Diego, and a member of the Programming Systems group. She received her Ph.D. in Computer Science from ETH Zurich in 2014, and then spent a couple years as a postdoctoral researcher at MIT. Nadia's research interests are in program synthesis, program verification, and type systems. She is a 2020 Sloan Fellow, and a recipient of the 2020 NSF Career Award and the 2020 Intel Rising Stars Award.
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.
Sukant 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.
Functional programming has finally escaped from academia. These days developers are building real systems in functional programming languages like Clojure, Scala, Elixir and F#. Functional techniques are also seeping into more traditional languages like Java and Ruby. Unfortunately somewhere along the way functional programming has also developed a reputation for being deep and mysterious: Good programs achieve the Zen-like state of being functional which somehow involves immutability, higher order functions and being referentially transparent.
In this talk Russ Olsen will strip away the cloud of mystery to uncover the simple — and wonderful — truth about functional programming: It can make your programming life easier by letting you do simple things simply while also providing you with the sharp tools you need to tackle more complex problems.
Russ Olsen has been building software for 35+ years, everything from engineering document management systems to database query engines. Russ has been on a career long quest to find a better programming language and was an early adopter of Clojure, Ruby, Java and Python. Russ is the author of Getting Clojure as well as two books on Ruby, Design Patterns in Ruby and Eloquent Ruby. Russ is a constant if sometimes reluctant conference speaker.
This talk offers a first look into Haskell and its ecosystem. We’ll explore questions like what is GHC or Cabal, how we distribute packages in the ecosystem, and what are the main sources of information in the community. After the talk, you’ll have a first map to help you in your Haskell journey.
Alejandro Serrano serves as a Senior Software Engineer at 47 Degrees, where he devotes his time to Haskell training and the development of Open Source projects for the Haskell ecosystem. Previously, he held several teaching and research positions at Utrecht University, where he obtained a Ph.D. in Software Technology (on the attractive-sounding topic of “error messages for compilers”).
Haskell is a top choice for building production software systems. While Haskell does have a large surface area, with many concepts and syntax that will feel unfamiliar to programmers coming from other languages, it is unrivaled in its combination of developer productivity, code maintainability, software reliability, and performance.
In this talk I will cover some of the defining features of Haskell that make it an excellent, industrial-strength language that is well-suited for building commercial software. You'll learn why we consider it our first choice for new projects, and why you should too.
Christian Charukiewicz is a Co-Founder and Partner at Foxhound Systems, a custom software development company with a focus on building fast, secure, and reliable software systems. Prior to founding Foxhound Systems, Christian was the CTO of a Chicago tech startup where he led a team of several engineers and drove the adoption of both Haskell and Elm as languages for building key components of the production system.
As a software engineer, you use types to represent the domain data that you are going to work with. The way you design the type architecture for the project also sets the direction on how the product evolves and is maintained through time. This makes thinking in types a crucial and important part of any software development process in any typed language. And even if you're using dynamically typed languages, you still try to structure your data and give it some shape.
Haskell's type system is one of the most powerful and developed at the moment. By using Algebraic Data Types (ADT), you can achieve extensibility, preciseness and flexibility at the same time. It's a powerful technique that greatly improves your development productivity. However, it can be challenging to think about data in terms of types. It requires good skills in designing, working and evaluating different solutions on types.
Focusing only on learning how to write functions without work on designing types could lead to a lack of knowledge on how to build some more complicated systems and completely eliminate the "type-safeness" of the project. That's why I want to talk more about types as I see it as the most important, the most difficult part of learning to engineer your code. And it could help to eliminate the whole layer of errors that could be possible due to the "wrong" type design.
In my talk, I'm going to dive into type systems, explain different aspects of Types, ADTs, Typeclasses and give lots of examples of how you can use types in the most beneficial way for you. I am going to walk you through the process of "making illegal states unrepresentable" and demonstrate how small changes to the type architecture of the product could lead to more precise domain representation and therefore more successful products.
Veronika Romashkina is a Functional Programming enthusiast with several years of experience of working with production Haskell in different fields. She is also a very active Haskell Community participant. She co-founded an OSS organisation – Kowainik, where she develops, maintains, and experiments with different libraries and tools; writes guides, tutorials and posts; mentors Haskell beginners and creates free educational materials.
Chordify is a popular music education platform, with a Haskell backend that handles hundreds of requests per second. To handle these requests efficiently, Redis is used as an in-memory cache. While Redis support various types of data, its type system is much more limited than Haskell's, so to work together with typed Haskell world and to prevent runtime errors, we have built a layer of Haskell code to deal with the interaction.
In this talk we present our Haskell-Redis layer, which supports strongly typed keys and values, transactions (which coincide with the Applicative class), multiple Redis instances, and locking. What we find interesting about this layer is that our usage of Redis is quite standard, and found in many pieces of imperative software too, but the composability and abstractions in our library make it easy for the programmer to create complex and bug-free interactions, which believe to be a bit less common.
Jeroen has been programming since primary school, but only once he started his study Artificial Intelligence at Utrecht University, he first encountered Haskell. He then did a PhD in the area of functional programming in the Software Technology group, doing research on incremental compilation. After succesfully defending his thesis in 2015, he started working at Chordify early 2016 and has been working there since. At Chordify, Jeroen has been actively involved in the (technical side of the) growth of the company.
Join us for this experience report from André van Meulebrouck:
I had a bug in my embedded lazy Scheme interpreter and couldn't figure it out in F#, so I did what I typically do when lost: prototype in Haskell.
After a complete conversion/rewrite from F# into Haskell, all known bugs were gone.
One of the biggest features of Haskell turns out to be the equational nature that allows writing and thinking with greater modularity.
Haskell isn't perfect for every use case — but it's a great way to really get clear on your thinking about a problem space.
André van Meulebrouck was introduced to functional programming through university coursework in the 80s through LISP.
I’m Mikael — the CTO of CarbonCloud, a climate-tech SaaS company, we help the food industry to solve their part of the climate crisis.
We use strongly typed functional programming languages exclusively – and that is a is a pure business decision.
In this talk I’ll cover how we capture knowledge as code to enable rapid growth, increase quality, reduce number of needed tests and more easily include non-developers in discussions.
This is my attempt to show why we use strongly typed languages such as Haskell and why I think others, especially managers, should push for more these techniques and tools in their organizations.
Mikael Tönnberg is the CTO of CarbonCloud, a climate-tech SaaS company.
The goal of this talk is to explain delayed arrays, that are available in massiv library, as well as their roles in fusion and parallelization of operations applied to multi-dimensional arrays.
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 pseq and relying on GHC's spark pool is not applicable to unboxed arrays because it relies on laziness. Combination of a custom scheduler and delayed arrays can help us with a solution, so we can benefit from multi-core parallelization.
Alexey Kuleshevich 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 massiv, hip and Color as well as maintaining a couple of core libraries, namely vector and random
The external STG interpreter is a from scratch implementation of the STG machine in Haskell. Currently it supports almost all GHC primops and RTS features. It can run real world Haskell programs that were compiled with GHC Whole Program Compiler (GHC-WPC). GHC-WPC is a GHC fork that exports the whole program STG IR.
The external STG interpreter is an excellent tool to study the runtime behaviour of Haskell programs, i.e. it can run/interpret GHC or Pandoc. The implementation of the interpreter is in plain simple Haskell, so it makes compiler backend and tooling development approachable for everyone. It already has a programmable debugger which supports step-by-step evaluation, breakpoints and execution region based inspection. It also can export the whole program memory state and call-graphs to files for further investigation. These features makes it easy to find a memory leak or to identify a performance bottleneck in a large real world Haskell application.
Aravind Gopal Mallapureddy is a software engineering at Juspay.
The external STG interpreter is a from scratch implementation of the STG machine in Haskell. Currently it supports almost all GHC primops and RTS features. It can run real world Haskell programs that were compiled with GHC Whole Program Compiler (GHC-WPC). GHC-WPC is a GHC fork that exports the whole program STG IR.
The external STG interpreter is an excellent tool to study the runtime behaviour of Haskell programs, i.e. it can run/interpret GHC or Pandoc. The implementation of the interpreter is in plain simple Haskell, so it makes compiler backend and tooling development approachable for everyone. It already has a programmable debugger which supports step-by-step evaluation, breakpoints and execution region based inspection. It also can export the whole program memory state and call-graphs to files for further investigation. These features makes it easy to find a memory leak or to identify a performance bottleneck in a large real world Haskell application.
Csaba Hruska is a software engineer and I'm into compilers and pure functional programming. I'm doing Research & Development. I'm working on the GRIN Compiler Project. (GHC, LLVM, ASM, pointer analysis, optimization)
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.
Duncan Coutts has more than twenty years programming experience with Haskell in academia and industry. He is a well known member of the Haskell community and is a founding partner of the Haskell consultancy Well-Typed.
There are three main sources of of quadratic blow-up in the ghc core code generated during compilation. First, we cannot refer to or update a field of records without mentioning all the fields of that record, where it should be noted that type class dictionaries are also records. Second, lack of type level sharing results in a lot of duplication when using data types with constructors that reflect some kind of inductive structure. Third, type family reduction results in large type equality coercions.
In this talk we will take a closer look at each of these problems. We will see how the large-records library manages to circumvent all of these problems, but we will also discuss the principles involved in the hope that you can apply those in your own code. Although it would be good to tackle these problems at a more fundamental level, this talk focuses on how to deal with these problems with current-day ghc, not a hypothetical future one.
Edsko de Vries has been using Haskell for nearly 20 years. For roughly half that time has been a professional Haskell consultant with Well-Typed , where he has provided training across the world, from Johannesburg to Boston to Singapore. He has worked on a large variety of projects, both open source as well as closed source for specific clients. Some of the open source projects he has contributed to are Cloud Haskell, Hackage, the Hackage security library, ghc, Ziria (a DSL developed by Microsoft) and cabal. Some general purpose libraries he has (co)developed include generics-sop, nothunks, recover-rtti and large-records.
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.
Harendra Kumar has decades of experience building large-scale software systems. Before founding Composewell Technologies, he was a file systems architect at NetApp, where he worked on the WAFL file system performance and resiliency.
He is passionate about creating software development tools to make it easy to build high-quality, maintainable, and high-performance systems. He has been working exclusively on pure functional programming using Haskell for the last several years.
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.
Jacob Leach is interested in the design of functional programming languages, type systems, and program verification.
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.
Luc Tielen is a freelance software engineer on a never-ending quest for writing correct, robust, and maintainable programs. Along this journey, he came into contact with functional programming via Elixir and Haskell and has never looked back since. Recently, he's been focusing on writing an optimized runtime for his Eclair Datalog language using the Haskell LLVM bindings.
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.
Marcin 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.
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.
Krzysztof Gogolewski is a software engineering at Tweag, working on linear types in GHC.
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.
Pepe Iborra is a software engineering at Facebook.
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:
<0l style="text-align: left; font-size: 13px !important;">
Sam Derbyshire: In 2017, having completed my mathematics PhD in London (in the field of p-adic Hodge theory), I decided to go back to my roots in the French Pyrénées, to begin working on various Haskell projects, with a focus on graphics. I got to know Haskell's type system in the process, and decided to take things a step further this year: I begun working on GHC under the supervision of Richard Eisenberg, with a focus on type-checking plugins and representation polymorphism. Since then, I've started work at Well-Typed, and continue contributing to GHC.
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.
Trevis Elser is a Software Engineer at Flipstone Technology Partners, Inc. Trevis 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.
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. linear-base, the standard library for linearly-typed Haskell programs, provides a fair number of utilities making -XLinearTypes convenient and also implements some of these new abstractions.
There are many in-depth articles and talks about specific uses of linear-base, but this talk will provide a broader overview of what is possible with linear-base now; walking through the different areas of the library pointing out their practical use cases; but also what they are lacking and what is being discussed. I hope it will encourage more people to experiment with linear-base, take part in discussions and become contributors.
Utku Demir 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 ormolu code formatter and had a part on shaping the linear-base project.
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.
Xiaoyan 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.
