YOW! Lambda Jam 2021

Wednesday, 5th - Thursday, 6th May, Online Conference

19 experts spoke.

YOW! Lambda Jam returns 5 & 6 May 2021.

YOW! Lambda Jam is an opportunity for applied functional software developers working in languages such as Scala, Elixir, Erlang, and Haskell to enhance their software development skills using the principles, practices, and tools of functional programming.

YOW! Lambda Jam has been the go‑to conference for functional programmers in Australia since 2013. Now in 2021 you'll have the chance to learn and share with functional programmers from around the globe by joining us online at our two-day conference, featuring invited international and Australian experts — including keynotes from Simon Peyton Jones and José Valim.

Eugenia Cheng on stage

This year’s YOW! Lambda Jam will take place online.

Talks will be delivered live and followed by an asynchronous Q&A via chat.

We’ll schedule ample breaks so you have time to grab a coffee before networking and interacting with speakers and other attendees, and we are investigating safe and practical ways for attendees to interact face-to-face as part of the conference.

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.

We are excited about the opportunity to truly welcome the functional programming community to this year’s Lambda Jam, no matter where you are in the world. We hope to see you there!

Explore YOW! Lambda Jam 2021

Get involved, plan your conference, or start your learning today

Ed Kmett on stage

View the programme

Our two-day online conference features expert-led talks including keynotes from Simon Peyton Jones and José Valim.

Attendees in a Lambda Jam workshop working on their laptops

Revisit 2020

View (or review) the talks from Lambda Jam 2020.

visit the library

Excited? Share it!


Connecting the dots - building and structuring a functional application in Scala

Functional programming relies on building programs from orthogonal, composable blocks. That's likely one of the reasons why full-blown application frameworks haven't gained much traction in the functional ecosystem.

However, we still need to structure our code and wire up our applications in a way that lets us keep them modular, testable and simply pleasant to work with - in this talk, we will learn how to do just that!

In this talk, we will walk through the architecture design and testing setup for a functional app on the Typelevel stack that integrates with several third-party services to process data in a streaming fashion, and expose its results to downstream clients.

Jakub Kozłowski

Scala Developer
Disney Streaming Services

A History of Enterprise Monads


The early 2010’s were exciting times for Scala. The language & ecosystem started to professionalize, both from a technical (binary compatibility) and a community point of view (many conferences were started). Not too long after Lightbend – then Typesafe – was founded, I registered the typelevel.org domain on a whim and put together a rudimentary website advertising a few FP-minded Scala libraries. Fast forward to today: Typelevel is known for a wealth of functional libraries, beginner-friendly educational resources, a series of conferences and a distinct ecosystem – including a custom compiler – within the Scala community. In this talk, I’d like to examine what got us there and into the mainstream.

Lars Hupel

Senior Consultant

Resource Analysis with Refinement Types

Liquid Haskell is an extension of Haskell’s Type system that allows annotating types with refinement predicates. It’s great for ensuring the correctness of your code, but it can also be used to improve the performance of your code.

If you track your resources then Liquid Haskell can be used to statically bound the resources needed at runtime, thus statically deciding how performant your code is. You are liquidating your assets.

To track resource we define a `Tick monad that ticks each time a resource (ranging recursive calls to thunks) is used. Then we use refinement types to statically approximate the number of ticks that can occur at runtime. This reasoning aids runtime code optimization, since it can be used to compare resource usage of two different programs.

In this talk, I will present this technique through small examples (sorting algorithms and mapping) and discuss the advantage and current limitations on real-world code adaptation.

Niki Vazou

Research Assistant Professor
IMDEA Software Institute

In The Belly Of The Whale: Tales From Haskell In The Enterprise

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 nearly 3 years and have lots to report. 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.

David Vollbracht

Flipstone Technology Partners, Inc.

Trevis Elser

Software Engineer
Flipstone Technology Partners, Inc.

Eliminating Bugs with Dependently Typed Haskell

Using dependent types in production Haskell code is a practical way to eliminate errors. While there are many examples of using dependent Haskell to prove invariants about code, few of these are applied to large scale production systems. Critics claim that dependent types are only useful in toy examples and that they are impractical for use in the real world. This talk analyzes real world examples where dependent types have enabled us to find and eliminate bugs in production Haskell code.

Noam Zilberstein

Software Engineer

Hashing Modulo Alpha Equivalence

In many applications, one wants to identify identical subtrees of a program syntax tree.  This identification should ideally be robust to alpha-renaming of the program, but no existing technique has been shown to achieve this with good efficiency (better than O(n^2) in expression size). We present a new, asymptotically efficient way to hash modulo alpha-equivalence. A key insight of our method is to use a weak (commutative) hash combiner at exactly one point in the construction, which admits an algorithm with O(n*(log n)^2) time complexity. We prove that the use of the commutative combiner nevertheless yields a strong hash with low collision probability.

Simon Peyton Jones

Senior Principal Researcher
Microsoft Research, Cambridge

Idioms for building fault-tolerant applications with Elixir

This talk will introduce developers to Elixir and the underlying Erlang VM and show how they provide a new vocabulary which shapes how developers design and build concurrent, distributed and fault-tolerant applications. The talk will also focus on the design goals behind Elixir, use cases, and include some live demos.

José Valim

Chief Adoption Officer

Journey to the Centre of the JVM

What do you do when your quest for power leads you to implementations which are not just platform- but processor- and even architecture-version-specific in nature? How do you even start tracking down a bug in a Scala-based implementation which is not only non-deterministic but only manifests on certain hardware? In this talk, we will dive into the wild and ill-understood world of CPU architecture, memory models, and JVM intrinsics (all through the lens of very high-level purely functional abstractions!) as we examine the story of the most convoluted and mind-bending bug hunt of my entire career.

Daniel Spiewak

Principal Engineer
Disney Streaming Services

Effective Programming in OCaml

Effect handlers have been gathering momentum as a mechanism for modular programming with user-defined effects. Effect handlers allow for non-local control flow mechanisms such as generators, async/await, lightweight threads and coroutines to be composably expressed. The Multicore OCaml project retrofits effect handlers to the OCaml programming language to serve as a modular basis of concurrent programming. In this talk, I will introduce effect handlers in OCaml, walk through several examples that illustrate their utility, describe the retrofitting challenges and how we overcome them without breaking the existing OCaml code. Our implementation imposes negligible overhead on code that does not use effect handles and is efficient for code that does. Effect handlers are slated to land in OCaml after the addition of parallelism support.

K C Sivaramakrishnan

Research Associate
University of Cambridge

Elixir for UAV Avionics

Fault tolerant, concurrent, distributed and functional with superior binary wrangling capabilities and network/device connectivity - the Erlang platform designed to run the world's telephony systems also turns out to be a perfect fit for autonomous aerial vehicle control software.

In this presentation Robin will give a brief introduction to  the world of autonomous aircraft, autopilots, onboard companion computers, ground stations and communication links. He will demonstrate the use of his open source Elixir MAVLink library to communicate with an Ardupilot autopilot from Elixir code, which in turn will control an  accurate X-Plane simulation of a large UAV he has been working with since 2014.

Robin Hilliard

Founder and CTO

Cultivating an Engineering Dialect

Haskell has seen success in commercial environments, with teams of professional engineers choosing it for its claims of reliability, a rapid development pace, and easier maintenance over the long term. On top of that, a large community of hobbyist tinkerers and academic researchers are always releasing new and exciting abstractions, libraries, and language extensions, each offering improved ways to structure, build, and test our programs.

Engineering teams have diverse knowledge and skill levels, and new team members need to come up to speed to work effectively. This poses us a challenge: which abstractions, libraries, and language extensions should we choose from the ever-growing pool? How should we determine what level of Haskell to adopt? Should we always embrace the cutting-edge to squeeze out every advantage, leaving new hires in the dust? Should we reject novelty and focus only on the “simple” or “boring” ways of doing things, even if doing so gives up some potential effectiveness?

This talk will bring clarity to these questions. Rather than prescribe a uniform solution, we offer you the tools of thought to make informed, intentional decisions, and cultivate an engineering dialect that works for you.

George Wilson

Functional Programming Engineer

Abstract Fun-sense: a functional perspective on life

Everything can be a function if you look at it the right way; we can characterise familiar concepts like sets, lists and even plain values as functions.

Thinking about such basic objects as functions can seem unnecessarily abstract, but it isn’t just an exercise in increasingly intimidating notation! It turns out to be an elegant perspective that allows us to glimpse a more powerful abstraction.

In this talk, we’ll see how playing with this notion leads to the Yoneda Lemma, a key result in category theory. We’ll build up some intuition and motivation for the Yoneda Lemma, and return to the notion of viewing objects as functions to appreciate some of its implications.

Dana Ma

Staff Software Engineer

Unison: a friendly programming language from the future

Unison is a new open source functional programming language based on a simple idea with big implications: every type and definition in the language has a unique cryptographic signature, determined by its content. Instead of a bag of mutable text files, the Unison codebase is a distributed immutable data structure and the signature serves as a global address into this structure. This is the basis for some serious improvements to the developer experience. Unison has no builds, no dependency conflicts in the traditional sense, and it allows for easy dynamic deployment of code in a distributed setting.

Rúnar Bjarnason

Unison Computing

G'Day, Nerves!

What is Nerves? What's the community like? How is it used?? These and more to be answered by this adventure into the world of functional embedded development using Elixir and the BEAM VM to create fault tolerant hardware systems...or blinking LED's...YMMV

Jon Carstens

Core Team

Phoenix LiveView: Building Scalable Web Single Page Apps Doesn't Have to Hurt

Meet Phoenix LiveView, the Elixir-based programming environment for Phoenix. The author of Programming Phoenix LiveView and LiveView trainer will walk you through how the programming model works. Along the way, you'll see what web development is supposed to feel like. The best thing? You'll be able to build the interactive single-page apps your customers want without compromising on code organization or writing custom JavaScript.

Bruce Tate


A tale of Nix and Nickel

What do package management and functional programming have in common? More than it seems!

In this talk, I will introduce the Nix package manager, which applies principles from functional programming to overcome fundamental challenges of package management. It crucially relies on a functional programming language, also called Nix, of which I will discuss the current state and shortcomings. I will finish presenting our new configuration language Nickel which attempts to solve some of them.

Yann Hamdaoui

Software Engineer
Tweag I/O

What’s new in F# 5.0 and beyond

The F# language delivers practical, enjoyable, and productive programming for the era of the cloud. At the core of F# is succinct, performant functional-first programming, compiling to both .NET and Javascript, with cross-platform, open-source toolchains for those at home in either ecosystem.

In this talk I’ll describe how in F# 5.0 and beyond we are adding more magic right across the F# stack – keeping programming simple and correct yet delivering the features you need for maximum productivity:

  • Added expressivity and performance for DSLs using F# computation expressions
  • High-performance state machines and resumable code for functional DSLs for collections, tasks, asynchronous sequences, and more
  • Improved package management integration in F# scripting
  • Interactive notebooks and a wide range of other tooling improvements
  • F# analyzers, e.g. for additional shape checking in AI tensor programming
  • Turnkey programming stacks for the client, server, and full-stack programming

Join me for this walk through the latest in 2021 for F#

Don Syme

Principal Researcher
Microsoft Research, Cambridge

Testing smart contracts with QuickCheck

I will talk about some recent work on a random testing framework for smart contracts on the Cardano blockchain--which supports the world's largest "proof of stake" cryptocurrency. In contrast to the Ethereum blockchain, Cardano contracts are written in Haskell, but of course, they still need to be tested. I'll talk about the testing framework we've built, and its most novel aspect: not only must we test that nothing bad ever happens, but also that something good is always possible.

John Hughes


Other Years

Thank you to our sponsors and partners