All About a Fold

Folds are the bread and butter of functional programming, but what are they, really? What do they mean? Let's take a look how folds encode structural recursion. We'll move beyond folding over lists by generalizing to any data structure, and in the process, we'll unravel the deepest and darkest mysteries behind folding.

Named and Typed Homoiconicity

A compiler can be thought of as an interpreter over its own language from the source language into another language. But can we control the execution of that interpreter? Yes, and doing so is called metaprogramming. Simple examples include generics and inheritance, while more complex examples include Template Haskell and dependent-typing. Metaprogramming can be greatly simplified by making a language's syntax mirror its formal grammar, which is a property called homoiconicity. The most famous homoiconic language is Lisp, in which programs are constructed entirely from heterogeneous lists. While far simpler than in most other metaprogrammable languages, metaprogramming in Lisp suffers from the 'magic number' problem of indexing into heterogeneous lists. Thus, this talk will explore some homoiconic language designs that rely on name- rather than index-manipulation for metaprogramming. You will learn that it's quite tricky to add good static typing to a homoiconic language, because it's difficult to express type- and value-expressions in a way that unifies grammar and syntax. To overcome this problem, the speaker introduces an unusual approach to homoiconic static typing that is centered around a language the speaker is developing.

Panel: OOP Versus FP

Object-oriented programming has long been the dominant paradigm for writing software. FP is a new challenger, eschewing encapsulation of state in favor of immutability. In this panel, you'll get to hear speakers discussing the tradeoffs between the paradigms, the analogues of one feature in the paradigm of another, and thoughts on if and how FP might ultimately supplant OOP as the dominant paradigm for developing software.

Introduction to Non-Violent Communication

Dysfunctional communication has destroyed many teams and communities of software engineers. Yet despite the importance of communication, it is not always easy or obvious to know how to express ourselves in ways that bring us together rather than pushes us apart. Nonviolent communication, a process developed by Marshall Rosenberg beginning in the 1960's, is a synthesis of communication and intentionality that offers us a simple yet complex map in finding ways to create communication and connection with others. It focuses on three aspects: self-empathy (defined as a deep and compassionate awareness of one's own inner experience), empathy (understanding and sharing an emotion expressed by another), and honest self-expression (defined as expressing oneself authentically in a way that is likely to inspire compassion in others). In this hands-on workshop, learn the basics of NVC and how it can enrich your ability to communicate and deepen your understanding of others.

Defending Erlang (Through Offensive Behavior)

Erlang, an elegant and powerful language, has been widely adapted by tech startups and established companies of all types. One common argument for the use of Erlang is its resistance to security threats inherent to lesser programming languages. While many of the perceptions of Erlang's security hold true, there are subtleties in the language that can result in remote compromise if not properly guarded against. Application business logic, third-party library issues, and even Erlang OTP VM issues will be discussed to depict how applications can become subject to adversarial manipulation. This talk is based on the speaker's experience reverse engineering the Erlang OTP Virtual Machine, as well as writing actual exploits against Erlang OTP and third-party libraries. Examples shall be given.

On The Shoulders of Giants

To appreciate the power of pure functional programming one needs to look beyond functions as values, closures and currying. In this talk, we will be standing on the shoulders of giants and observe a brand-new field of tools: disjunctions, applicative functors, validations, and HLists. Code examples will be presented in Scala using scalaz, cats, and a little of Shapeless.

On the Descent of Programs from Reconfigurable Hardware

As a rule, programs are specified in flexible, virtualized environments - the mind of the programmer, high level source languages - and ultimately implemented in the constrained, physical environment of a machine's logic circuits, traversing some number of more or less fixed translation layers in-between. Dynamic, partially reconfigurable hardware, primarily Field Programmable Gate/Transistor Arrays, bend this rule by exposing designated portions of their circuitry to functional modification - portions, but not the whole. The speaker will present on Pervasively Reconfigurable Computing, an ongoing project to build a computing device that is homogeneously, component-wise reconfigurable, at a finer-grained scale than FPG/TAs. Specifically, a proposed primitive hardware element is described, the Universal Cell, which extends Reversible Logic Elements with Memory (Morita, 2013) with certain features of Reconfigurable Asynchronous Logic Automata (Dalrymple, 2011). This talk will contain a bit of theory, a bit of philosophy, and a bit of Scheme code.

A Gentle Introduction to Recursion Schemes

Recursion Schemes, popularized by the notorious paper Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire, is an very elegant technique for expressing recursive algorithms on arbitrarily nested data structures. This talk will offer a gentle introduction to the subject. We will begin by motivating its use and then follow through with some intuition for the concepts and finally walktrough some concrete examples. Only basic familiarity with functional programming abstractions will be assumed. The audience can expect to leave with a burning desire to write all their recursive data types in fixed point style.

Beginner’s Guide to Programming with Immutability

Every journey into functional programming starts with this one thing: programming with immutable data structures. In this hands-on workshop, you'll learn what immutable data structures are as you build an immutable list and an immutable map. Then you'll learn how recursion enables beautiful, comprehensible, and composable programming on immutable data structures. Along the way, you'll get a chance to see how functional programmers can solve the same real-world problems that imperative programmers solve, but with code that's easier to reason about. Come with your laptop, and a rudimentary knowledge of Javascript (though you are welcome to follow along with any other programming language of your choice!).

Panel: The Functional Front-End

The days of writing Javascript on the front-end are long over, and now developers interested in writing functional code on the front-end have lots of choices, including Elm, PureScript, Scala.js, TypeScript, and others. Join our hand-picked panel as we explore the landscape of approaches to functional programming on the front-end, and discuss the tradeoffs that every choice has as compared with plain vanilla Javascript. Discover what's the best choice for you on your next front-end project!

Agda from Nothing

Learn the basics of Agda from the ground up. Using Agda as our playground, we will work through essential concepts including types, functions, totality, termination and equality. Discover the correspondence between proofs and programs by constructing both in a single formal system.

Emm: A Sane Alternative to Monad Transformers in Scala

This talk will cover the fundamentals and deep-down-dirty details of Emm, a monadic abstraction for composing arbitrary monads in Scala. Unlike Oleg's Eff, which is a mechanism for composing effects, Emm is about composing monads which themselves may represent effects. Emm is implemented entirely at the type level, using very similar machinery to what is foundational in Shapeless. This talk will examine the motivation and use of Emm, as well as its deep, dark implementation details, including lessons and techniques learned and refined through its development.

Elm 101.5

In this hands on introduction to the Elm programming language, you'll get to see how TEA (The Elm Architecture) forces you to structure your code, and how we can use this structure to build a simple application. We will build out a simple ordering interface, and demonstrate how we respond to user input and provide useful computation. After you are done with the workshop, you will be able to use TEA to structure logic for your next web application, even if you aren't using Elm!

Programming with Algebra

Text parsers, GUI controllers and actors have more in common than you might think. Currently, they are often programmed using anonymous methods, also known as lambdas. With these you program parser combinators, futures, event handlers, execution in different threads. All nice engineering, but the toolbox has become big and incoherent. To deal with this problem, we have extended Scala with an expression syntax that was inspired on the Algebra of Communicating Processes. This allows clean and crisp expression of nondeterminism, event handling, concurrency, and more.Boilerplate code vanishes; what remains is all algebra, without you noticing. You will see surprising resemblances between parsers, GUI controllers and actors, and many other patterns are still being discovered. Learn them all as you explore the topic in this hands-on workshop.

Introduction to Functional Programming through Javascript

Do you find yourself intimidated by unfamiliar notation and strange concepts when coming to functional programming? Come get a gentle introduction to this vast topic through the ubiquitous Javascript! We will take a plain looking bit of Javascript and steadily transform it using functional principles until we are left with something that, if you squint, looks a darn lot like what you get with one of those fancy languages. Topics covered: Maybe instead of null, map/filter/fold instead of for, partial application, functions as an expressions instead of a series of statements.

Introduction to Tabled Logic Programming with Picat

Picat is a new logic-based multi-paradigm programming language. Picat shares many features with Prolog, especially B-Prolog, but also has many distinct features: optional destructive assignments, functions in addition to predicates, explicit non-determinism, list comprehensions. Picat supports tabling: a form of memoization for logic programs. Tabling helps to avoid getting stuck in an infinite loop and allows easily formulating solutions for dynamic programming problems. Picat's tabling-based 'planner' module can be used to declaratively solve AI planning problems. Learn how to do all this and more in an in-depth, hands-on workshop!

Revealing Intent: Typed Development in Standard Javascript

We will look at using the type system in Javascript as well as a lightweight library to reveal information about API endpoints to others, including our future selves. We will explore core Javascript types, attaching metadata to functions as a mechanism for conveying function contracts and how types and subtypes communicate information to API consumers.

Mob Programming: An Experience Report

The speaker will be presenting about the speaker's personal experience joining a mob programming group. A long-time agilist, the speaker experienced a bit of culture shock, no longer being 'The Expert' on the new team. The speaker needed to learn a lot of new skills to be effective in the environment — skills the speaker never imagined would be necessary to improve! The speaker will discuss what those skills were and the positive and negative aspects of transitioning into this different way of coding. Finally, the speaker will show how, quite indirectly, mob programming eventually lead to the speaker embracing functional programming, even though no one else on the team did!

Computing vs Computers

Dijkstra once said that 'Computer Science is no more about computers than astronomy is about telescopes.' Imagine a world where programmers think not in terms of computers, but in terms of computing. In that world, programmers and businessmen don't focus on 'finished products'; they focus on development processes and customer interactions. What counts as cheaper is not a shorter source file and smaller binary but a shorter interaction loop and a system overall easier to reason about. There are no 'operating systems' and 'standalone applications'; there are 'interactive platforms' and 'extensions' (just like Emacs, only less antiquated). There is no painfully serializing data and saving it into file systems or databases, then painfully getting it back; there is pervasive data persistence. Virtualization isn't an advanced technique for system administration; it is a basic programming language feature. Meta-level programs aren't just arcane static code generation techniques; they are the regular way programs are built and combined, at runtime as well as compile-time. A relatively simple switch in how you look at programming will lead to vastly different conclusions on what software architecture should look like, on what software development best practices are, on what software business can be.

P.S. You Can Print Functionally, Too

Your printer implements a fully Turing-complete language: PostScript. PostScript is a concatenative language (also known as a stack-based language) with the standard set of datastructures that you expect from a modern scripting language and a garbage collector. However, thanks to its unusually exposed VM internals, function composition in PostScript turns out to be unexpectedly simple — and then it's off to the functional races. In this talk, we'll introduce PostScript for those who don't care about printing, then show how a comfortable FP environment can be created with only a few combinators. Then, because it's PostScript, there will be pretty pictures.

Type Kwon Do

Fear no type signature! We will begin the workshop with a presentation on polymorphism and parametricity. Then we'll work through a series of exercises designed to help you become comfortable with reading types and with the ways parametricity constrains and guides programs. We'll also cover how to turn GHCi's typechecking into a friend rather than a foe, until you're a master of type manipulation. This workshop will be exercise-intensive. The language used will be Haskell. Participants should have basic familiarity with Haskell syntax and have GHC 7.10 ready to complete exercises.

Functional Programming Without a Functional Language

Functional languages have given rise to many powerful idioms, like parser combinators and iteratees, for managing the flow of data. What's a developer stuck with a procedural language to do? Never fear — a sufficiently stubborn programmer can implement functional idioms in any language. In this talk, we'll explore the internals of Hammer, an experimental parser combinator library, which targets context-sensitive, context-free, and regular parsing backends and is written in C. We'll also look at nom, which combines Hammer's approach with Rust's macro system to produce blindingly fast parsers. Finally, we'll talk about the security benefits of functional input handling with a real-world case study drawn from the world of industrial control systems.

Functors, Comonads, and Digital Image Processing

Digital image processing is one of the most researched computational fields, but what insight can category theory and equational reasoning bring? In this presentation, we explore the denotation and implementation of ideas in digital image processing using comonadic approaches based on the Store comonad and build towards a clean denotative framework for describing and building ideas and concepts in digital image processing, where equational reasoning can be applied by programmers and compilers alike to refactor algorithms. Along the way, we look at the implications of such an approach to other interesting computational domains.

Getting Started with Functional Programming in F#

Functional programming is one of those things that's only good for math and statistics and stuff right??? Wrong! In this session we'll start from scratch and code a multi tier application using functional techniques. Attendees will see F#'s Type Providers which are used to statically type check our data access, and asynchronous data access to help the app scale. This is a live coding talk designed to show unique features of the F# language and how it is directly applicable to solving business problems.

Algebraic Operations and Derivatives on Algebraic Data Types

In this talk, the speaker will be talking about some ways in which to perform math on types! In addition, the speaker will demonstrate that types form a star semiring structure, and talk about different ways in which to perform derivatives (or dissection) on types to create efficient traversal algorithms. Attendees should be familiar with a statically-typed programming language.

Monstrous Names Aren't Scary: A Beginners' Bestiary

Ever wondered what lenses are good for? How about free monads or tagless-final interpreters? What's all of this abstract algebra and category theory gobbledygook, and why is it in my standard library? In this talk, the speaker will cover 10 common design patterns in functional programming, why they're important, how they're commonly used in industry and where to find out more about them. Accompanying materials will contain small but meaningful examples of each pattern that can be adapted for use in your language of choice!

Index Your State for Safer Functional APIs

In statically-typed functional programming, we usually prefer to write safer APIs that use types to guide us through proper usage, instead of relying on documentation or throwing errors at runtime. The Indexed State monad is a simple way of taking the state monad we all know and love and expanding it to allow for more control at the type level in the composition of state functions. In this presentation, the speaker will show small practical examples of this technique being used in the wild and hopefully inspire you to upgrade your state monads to indexed state monads!

Intuitionistic Logic of a Database Schema

In this talk, we'll work off a foundation of intuitionistic type theory to show how database schemas can naturally produce first-order intuitionistic logic. Attendees should have a basic familiarity with type theory.

Functors, Monads, & More In Scala

Knowing a functional programming language like Scala is just the first step into the enormous world of functional programming! In this presentation, the speaker will guide you through a series of common functional idioms in the Scala programming language. The talk is entirely self-contained, and assumes no prior knowledge of category theory or functional programming libraries (such as Cats and Scalaz).

psp-std: A New Non-Standard Standard Library for Scala

Scala's standard library has been widely criticized for inconsistency in both architecture and performance, its complexity (especially in the collections hierarchy), and the strange combination of features it chooses to include and exclude. In this interactive code walkthrough, the speaker will highlight the main sections of psp-std, a new (non-standard) standard library for Scala that tries to rectify many of the deficiencies of Scala's built-in standard library, while at the same time aiming for much more modest and consistent coverage goals.

Powering Concurrency with Synchronous Messaging in F#

One of the four tenets in the Reactive Manifesto is asynchronous messaging, but what if we considered the alternative? Synchronous messaging may not be the sin we've all been warned against. Inspired by Concurrent ML and the concurrent synchronous processes model, we will discuss the concurrency primitives exposed by the Hopac library and how they can be composed to build highly-concurrent applications which benefit from lightweight threads, an optimized work scheduler, and the ability to react to multiple communication channels. All while avoiding some of the pitfalls of asynchronous messaging.

Building a Simple, Recursive Art Language in Racket

In this talk, the speaker will be presenting a little language, built in Racket, for drawing 'art', inspired by Chris Coyne's CFDG (the precursor to Context Free Art). The speaker will discuss how to put together a language in Racket, show some pretty pictures, and convince the audience that Racket is an interesting language for their toolboxes.

Shen Trick Shots

The speaker will present on Shen, the Lisp stunt-double that other languages wish they had! It is one of the most innovative statically- AND dynamically-typed languages around, and by not picking a side, is more powerful and flexible than both. HLists? Cake. Type migration at runtime? No problem! Embedding another language, syntax and all seamlessly into Shen code? Done. Hate playing type-tetris with some random API? Want to parse the API and have a Prolog do it for you? Better Send Shen! The talk will cover these tricks and more with complete code examples. Shen knowledge is not required. Although this is NOT an introductory talk, it should be easy to pick up for experienced programmers. Familiarity with Lisp and or statically-types languages like Scala and Haskell will help.

The Parallels Between Community and Team

The speaker will be presenting personal ideas about community building in the technology realm based on personal experience running a meetup with thousands of members. The speaker will then draw parallels between growing and nurturing a community, and team development that leads to the best outcomes for both people and employers.

Parser Combinators in Swift

The speaker will be presenting about an implementation of parser combinators in Swift, based on Hutton and Meijer's paper 'Monadic Parser Combinators'. The talk will cover the basics of the paper, translating from monadic do notation to Swift, and a very simple introduction to the state monad in context.

Manuals are for Suckers: Using Free Arrows to Generate Program Semantics Directly from Source Code

Few things in software development are as banal, annoying, and ultimately essential as the user manual. In the modern world of fast, agile development cycles, keeping the DESCRIPTION of what an application does in sync with what the application ACTUALLY DOES can be a significant burden. In this talk, the speaker will be show how the generic computational abstraction of arrows [Hughes 2000] (in particular, free arrows) can be used to develop semantic details of an application in concert with the code itself. 'Flow chart' style diagrams as well as multi-resolution evaluation traces are generated 'for free' and directly from the code that is actually executed — meaning that the code and a human-readable, semantic representation of the code are always in sync. Methods for natural language generation can further exploit this representation to produce a program that can describe its capabilities even as the underlying codebase evolves. Motivating examples are taken from an legal automation platform written in Haskell.

Mastering Apache Spark

Yeah, we know, Spark isn’t pure FP, but hey, your boss needs a reason to pay for your ticket, right? Right! Apache Spark is the hottest big data technology right now, and it helps Scala and Java developers perform complex data processing, analytics, and machine learning over huge amounts of data. Based on principles common in functional programming (such as dataflow graphs), Spark has completely displaced the purely imperative map/reduce paradigm in favor of a design that is more declarative, easier to reason about, and less error-prone. In this intensive, hands-on workshop, you’ll learn how to install Spark, set up a mini Spark cluster, and begin using its multitude of powerful APIs to solve numerous problems in data processing and analytics. Bring that laptop, and prepare to become a bona fide Spark developer!

Real-World Gobbledygook

It's happened to all of us: we ran away from some conversation or library because it kept on using those 'weird' phrases. You know, like 'type classes', 'semigroups', 'monoids', 'applicatives'. Yikes! They all seem so academic, so pointlessly detached from real-world problems. But then again, given how frequently we run into them in functional programming, are they REALLY irrelevant, or do they have real-world applications? This talk will go beyond giving you raw definitions of these terms, and show you real-world motivations behind the concepts. By attending, you'll be able to keep your skills relevant to an ever-changing industry, confuse your significant other ('You know, honey, a monad is just a monoid in the category of endofunctors!'), and sound extra smart on the next job interview! Examples will be in Scala but the principles apply to any programming language.

MTL Versus Free: Deathmatch!

The Monad Transformers Library (MTL) in Haskell is a state-of-the-art library for describing and composing functional effect stacks in Haskell, the product of more than a decade worth of experience in effect composition. Many languages (including Scala and PureScript) have gotten their own versions of this library. However, the extensible effects revolution has proposed alternatives to MTL, which are often some variation of the Free monad abstraction. Until now, the benefits and tradeoffs of these competing approaches has remained unclear. Finally, for the first time ever, the speaker will pit MTL versus Free in a battle to the death! No matter which side you're on, you will come, you will see, and you will leave...well... probably more confused than before, but at least you'll have a good time while you're there!

A Board Game Night with Geeks

So this one day, I am playing the board game Quarto with my friend and I wonder, can this game end in a tie, or is there always a winner? Normal people might have squabbled or shrugged, but not us nerds! We obviously abandoned the game, took our laptops to the local pub and started hacking. In this talk I will explain how I used F# to transform this problem to satisfiability, ran it through a sat solver to discover if it can indeed end in a tie. I will also show how to apply the same technique to more useful problems such as scheduling and hardware testing.

Your Esoteric Benefactor: The Simple Richness of Lambda Calculus

It would be easy to think that lambda calculus is not much more than a bizarre and impractical form of abstract math. To the contrary, it is absolutely foundational to programming, not only providing a theoretical basis but also a rich set of simple, practical abstractions. Good abstractions are hard to come by; there seems to be an inverse relationship between simplicity and ease, so the plain but powerful lambda is an indispensable tool to the programmer. In this talk, the speaker will give an introduction to the untyped lambda calculus with an emphasis on the practical impacts for writing code.

RankNTypes Ain't Rank at All

In this intermediate Haskell talk, the speaker will begin with some brief motivation for polymorphism and parametricity, followed by an explanation of universal quantification. This will lead into an explanation of how to read Haskell type signatures and how type variables are quantified by default. Next, we'll look at an example of something you might naturally want to do that is inexpressible by default. This motivates the use of higher-ranked polymorphism, which is explained in detail with the Rank2/RankNTypes language extensions.

The Unreasonable Effectiveness of Erasure in the Evaluation of Monadic Structures

Evaluating monadic structures in Scala have always been a challenge, especially if you care about performance (and you should!). This sad situation comes mainly from the evaluation strategy used by the language coupled with the limitation of the virtual machine which hosts it. Over the years, Scala has pushed us into using sophisticated data-structures in order to find an acceptable solution due to this limitation. In this talk, the speaker will present a straight-forward approach which involves partially erasing the monadic structures to retain only the precise information required for their evaluation. We'll see how this approach can be used to port some of the great features from the Haskell and maybe shape the future of the Scalaz library.

Type Systems for Alchemy

Very few modern chemists do their work without writing programs of some kind. Chemical informatics tools and simulation packages all expose programmatic interfaces to describe molecules and reaction processes that operate on them. Most of these are bad. At best, you get a nice Python or Fortran08 library. At worst, you get an incomplete reimplementation of Simulink or an arcane markup format that was designed in 1972 and accepts only numbers and spaces! In this talk, we will explore the very interesting ecosystem of programming languages currently used in chemistry research and industry. Then we will attempt to apply the semantic magic we have in type theory and functional programming to design a new (and hopefully friendlier!) language for chemical simulation.

Functional Programming: Destination or Origin?

One of the reasons some developers get excited about functional programming is the ability to reason about your code mathematically. In fact, since you're (hopefully!) coming to LambdaConf, you're probably one of those developers. But there's more to mathematics than functions, so there's more to appreciate about functional programming than reasoning about your functions. In this presentation, the speaker will discuss the relationships among functional, logic, and probabilistic programming, using the functional perspective as the launching-off point.

How Environment and Experience Shape the Brain

Unlike other organ systems, the nervous system is not fully mature at birth. This is especially true for the brain, which undergoes a time of early-life vulnerability known as the critical period, during which time it is extremely malleable and responsive to stimuli. The use of environmental enrichment as an experimental manipulation and enrichment therapy as a treatment for humans has demonstrated that both early-life environment and experience are able to alter the shape and function of cells and circuits within the brain, as well as prevent and alleviate neurological disorders. This talk will cover the current enrichment literature and its implications for learning and brain health.

No, Really, Learning Clojure Was Hard!

'Everyone says Clojure is simple and easy, right? I'll quick learn it over the weekend!' So started the hardest two weeks of the speaker's development career. Two weeks later, the speaker was still struggling with the basics! Each line of code was a battle to comprehend all the new concepts. S-expressions? Macros? Wait, you can write it either (:key map) or (map :key)?! In hindsight, it looks so easy, the code legible. But when we forget how difficult it can be, we trivialize a new learner's struggles. We have to remember: sometimes learning Clojure is not easy!

Types for Ancient Greek

This project uses types to model linguistic research for ancient Greek. Starting with digital Greek texts, a series of mappings transform the texts into a type structure that encodes linguistic analyses. The types represent propositions about the Greek language and they account for every phenomenon found in the source texts. A web app shows the texts and every occurrence of each analysis within the ancient Greek corpus. The data processing code is written in Haskell.

Functional Reactive Programming for Natural User Interfaces

Functional reactive programming supports elegant programming of dynamic and reactive systems by providing first-class, composable abstractions for behaviors (time-varying values) and events (streams of timed values). Using Functional Reactive Programming to handle event-stream of values over time provides an alternative to the Observer pattern, which produces a series of unique responses to discrete changes in state. During this presentation, the speaker will create, consume and compose event streams with Observables introducing the concept of FRP integrating time flow and compositional events to build Natural User Interfaces with Kinect and Leap.

Typesafe Data Frames with Shapeless

Shapeless is generic programming library for Scala. Apache Spark is cluster computing framework. It has data frame abstraction for distributed manipulation of structured data with performance optimizations under the hood. In this talk, we'll look at how Shapeless is used to mirror value-level computation to type-level and provide more typeful experience working with Apache Spark.

Interactive Tests and Documentation via QuickCheck-style Declarations

Wouldn't it be absolutely wonderful if you could use easy, QuickCheck-style declarations to not just test your code, but also make those tests interactive to developers who want to learn more about how to use your functional library? Thanks to the power of applicatives and functional reactive programming, this is now possible! In this talk, the speaker will present a testing library that unifies property testing with interactive testing to make your functional programming libraries both well-tested and also accessible to new users!

Functional Web Programming: An Empirical Overview

In this talk, the speaker will present an overview of current functional web frameworks and compare them based on the simple experiment of building the same application in each. The emphasis will be on performance, usability, and interoperability with commonly-used software (SQLite, etc.). Languages covered will include Lisp, Haskell, OCaml, Erlang, Clojure, and Elixir. By the end of the talk, you'll have a feel for which of these languages and frameworks may suit your own personal preferences!

Functional Refactoring

Refactoring is one of the important processes in software development. It's also an accessible opportunity to learn about design patterns through experimentation. In this talk, we will explore examples of code written in familiar imperative programming patterns, and refactor each one using a counterpart functional programming pattern. Learn how to replace mutable variables with the state monad, loops with folds, thrown exceptions with sum types, dependency injection with the reader monad, and much more. As we go, we will build up a handy bidirectional map of corresponding imperative and functional patterns. This talk will use Scala to take advantage of its hybrid object-oriented and functional design, which caters to both imperative and functional patterns.

Queries Inside Out: The Algorithms of your Relational Database in Clojure

Relational databases are fast. How are they so fast? Algorithms of course! Join us as we turn the database inside out by demonstrating its algorithms in Clojure. From simple sorting to genetic algorithms, we'll see how the database performs its magic. Knowing how your database works will help you write better queries, choose optimal indexes and decipher the output of the query analyzer. You'll take home algorithms you can use in your applications, and gain a deeper understanding of why SQL databases are still state-of-the-art. With Clojure as our flashlight, this illuminating peak beneath the covers of SQL offers plenty to learn for experts and beginners alike.

Who Let Algebra Get Funky with my Data Types?

If you are confused or frustrated that the word 'algebra' could impose itself on a programming concept like 'data type', or even if you have never heard of algebraic data types (ADTs) before, this is the talk for you. Despite their imposing name, ADTs have great practical benefits. By allowing you to model your domain more closely, they both enhance the expressiveness of your code and help ensure the correctness of your program. In this talk, the speaker will explain how a type can be algebraic and suggest some practical benefits. Those who are less mathematically inclined are encouraged to attend as the speaker's approach is intuition-based rather than strict or rigorous!

Making the Best of a Bad Situation: Bending Toward FP in Java

If your day to day involves writing Java using mutable state, explicit iteration, copious null checks, and exceptions for flow control, it may seem impractical to apply LambdaConf's wondrous feats of functional programming. In a surprise twist of fate, this speaker recently returned to Java after years of writing Scala where the speaker had become accustomed to having principled tools. The speaker will share the libraries and techniques that the speaker found useful in helping coworkers enjoy turning toward a more maintainable, functional style. These lessons will apply even if the situation is so dire you don't have access to Java 8's lambdas!

Functional Algebra for Middle School Students

In this motivational talk we will go through the algebraic identities you learned back in Middle School and translate them one by one into type signatures of functions. Programming is modern technical communication, and we hope this talk motivates you to help local Middle School teachers put basic Functional Programming into their Algebra curriculum. For professional programmers, we hope you are motivated to refactor code using techniques you learned back in the 8th grade.

Program Derivation for Functional Languages

Program derivation of course was all the rage in the era of Dijkstra, but is it still relevant today in the age of TDD and model checking? This speaker thinks so! In this session, the speaker will show you how to systematically and step-by-step derive a program from a specification. Functional languages especially are very suited to derive programs for, as they are close to the mathematical notation used for proofs. You will be surprised to know that you already know and apply many techniques for derivation, like Introduce Parameter as supported by Resharper. Did you know that is actually program derivation technique called generalization? We will explore known and unknown techniques and study source code for our derived algorithms in C#, F# and Idris.

The Easy-Peasy-Lemon-Squeezy, Statically-Typed, Purely Functional Programming Workshop for All!

Maybe you've played around with functional programming before, but don't consider yourself a functional programmer. Or maybe you program functionally, but only in a dynamically-typed programming language. Or MAYBE you just like workshops with really long, ridiculously-sounding titles! No matter, this workshop that teaches the hot programming language PureScript is guaranteed to cure what ails you! Come, learn about functions, learn about types, learn about data, and learn about how to smash them all together to build beautiful programs that are easy to test, easy to combine, and easy to reason about. Become the functional programmer you were born to be!

Make Your Own Lisp Interpreter in 10 Incremental Steps

To truly understand something, you need to teach it to somebody else. A corollary is that to truly understand Lisp, you need to teach a computer how to do it. In other words, you need to write a Lisp interpreter! This may seem like a daunting task, but it is not as difficult as it might appear. You don't even need to know Lisp before you start. In this workshop, you will learn how to create a Lisp interpreter using the 'make-a-lisp' process, which is made up of 10 incremental steps. Each step builds on previous steps and demonstrates core principles of Lisp. Completing all the steps means you will have created a Lisp interpreter for a Clojure-like Lisp called 'mal' that supports macros, tail-call recursion/optimization, quasiquoting, exception handling and more. In fact, the resulting interpreter will be powerful enough to self-host (able to run a mal program that is itself a mal interpreter)! By the conclusion of the workshop, you will be armed with the knowledge and tools to create your own powerful Lisp interpreter. You can work through the steps using any sufficient powerful modern language (however, code examples shown during the workshop will be written in JavaScript, Python and Ruby).

The Missing Diamond of Scala Variance

A Scala programmer who wishes to abstract as much as possible, yet rely on subtyping polymorphism when doing so, will eventually hit the boundaries of what Scala makes possible. In this talk, the speaker will explain why variance matters if subtyping matters, why Scala's model of variance is incomplete, and this problem's relationship with GHC type roles. Attendees may also enjoy such digressions into abstract nonsense such as 'variance-contravariant', 'variance variables', and the like!

Urbit: A Clean-Slate Functional Operating Stack

In this talk, the speaker will present an overview of Urbit, with a quick design discussion of each of its three layers: Nock (a virtual machine defined in 200 words), Hoon (a strict, Higher-Order Typed functional language) and Arvo (a persistent nonpreemptive operating system), and show some demos.

The Next Great Functional Programming Language: Year 2

Last year, John De Goes gave a now infamous talk on the next great functional programming language, and set a new record for the amount of heckling possible in a 30 minute talk. This year, a new speaker with a different perspective rises to the challenge, arguing for a Lisp-based language that embraces compositional programming, category theory, gradual typing, proof-checked protocols, and bare-metal performance, all while eschewing boolean values, if/then/else conditionals, exceptions, and nulls. Warning: Leave those preconceptions about parentheses at the door and prepare to glimpse into the future!

Purely Functional Semantic and Syntax Expression Composition

Scala boasts a powerful type-system and a growing ecosystem of functional programming libraries. By combining these strengths with its ability to easily construct domain-specific languages, we can tame the complex problem of composing expressions that impose strong-typing on data from weakly-typed sources. By using the Cats library, in Scala, we will observe how to easily build fault-tolerant expressions with a customized natural syntax.

Functional Relational Programming In UI Programming

Functional Relational Programming is a system architecture approach based on functional programming and the relational model. It was introduced in the seminal paper Out of the Tar Pit, but never gained much support in industry. Now, 10 years later, has this approach finally been adopted? New frameworks in the browser UI space like Redux.js, Om, re-frame, and Elm have been gaining traction with non-OO system architectures. We can see some of the core ideas of Functional Relational Programming in common use with these new frameworks. In this talk, we'll discuss the fundamental aspects of Functional Relational Programming and its purpose, and how those aspects are being used in modern UI frameworks.

Functional Programming is Overrated

Functional programming is almost revered in some circles for its power to make code simple, composable, and comprehensible. However, these benefits have a darker side that's not as well understood or appreciated. Functional programming constrains code in ways that are heavy-handed and overbearing. In this talk, the speaker will be exploring practical imperative techniques to free your codebase from the shackles of Functional Programming. Recommended reading: 'I Am Null (And So Can You!)', 'Real World Primitive Types', 'Any => Unit for Dummies', '7 Exceptions of Highly Effective People'.

How to Use Covariance and Contravariance to Build Flexible and Robust Programs

In this presentation, you will get to learn all about the concept of Covariance and Contravariance. We'll explore what these names refer to, how the concepts are handled in various programming languages such as C#, Scala, and Swift, and how you can make your code more flexible and robust by taking advantage of this feature no matter what language you write in!

Witchcraft: Experiments Getting Higher-Order Abstractions into Elixir

Different families of (functional) languages have their own idioms, but are they compatible? Are there boundaries between these different ways of solving problems, or are they orthogonal? To explore this, we’ll take a look at the Witchcraft library, an experiment in bringing some otherwise foreign abstractions to Elixir (such as applicative functors and free monads). We’ll also briefly look at some bootstrapping combinators and data structures that were required along the way. Together, these enable very powerful programming patterns that might be familiar to those with experience in other functional languages.

What Would Happen if REST Were Immutable?

REST UIs have pervasive IO and mutability. Each CRUD resource is a high-latency, mutable cell, and this IO poisons the rest of the UI code. This talk presents an immutable application architecture to reframe the problem in a way that enables the relation: UI=f(state). We will demonstrate UI=f(state) is possible if we start with an immutable database, which enables idealized caching at all layers of the system. We will build REST on top (hint, it’s actually CQRS!). Finally we will explore how idealized caching in the UI changes UI performance and programming model. The result is HATEOAS, ACID, supports relational and graphs, no O/R impedance mismatch, can render on server or client from arbitrary state and served from CDN.

Dialyzer: Optimistic Type Checking for Erlang and Elixir

Static typing versus dynamic typing is an age-old debate amongst computer scientists and programmers, and the fact that we still argue about it suggests that there is no single right answer for all circumstances. But what if we could have the best of both worlds by combining the safety guarantees of static type systems and the freedom and flexibility of dynamic type systems? In this talk, the speaker will present an introduction to an optimistic, gradual type system as implemented by the Dialyzer tool for Erlang and Elixir. The speaker will highlight the differences and trade-offs between static and dynamic typing, and present optimistic, gradual typing as a good compromise between the two.

Extracting Useful Information from your Code Repository using F#

Our code repository stores a lot of information of how we work and how our code is. It's all there, waiting for you to get it. In this session we'll see how we can extract this information using FSharp. You'll learn how to use array manipulation, record types, pattern matching and type providers to get information about our code that can be used to improve it next Monday.

An Immutable State Machine

The State Machine is a semantic device that comes up a lot in many software architectures. The Nondeterministic Finite Automaton (NFA) is particularly interesting: as it has the ability to model more complex systems with a fewer number of states. We will be looking at a traditional way to construct such a state machine and then observe a more novel approach that is both purely functional and fully immutable using the State Monad, as defined in Cats. The presented code will be in the Scala language.

Discrete Time and Race Conditions

When dealing with any discrete-time system, the ordering of events is of the utmost importance. Computers are discrete not only at the level of quartz clocks and registers, but also at the higher levels of functions, data structures, objects, and IO actions. The execution of code will always be ordered, but we want it to be well-ordered: we want code to execute in the order we intended. This becomes difficult when the ordering becomes obscured, either through design choices (e.g., event systems) or through hardware dynamics (e.g., threading). The negative consequences are called race conditions, which are badly-ordered reads and writes to stateful resources. This talk will argue that it is discreteness of time and state that makes orthogonality so important; that orthogonality gives pure code its safety; and that embracing the discrete can bring much of that safety to impure code.

No If's, Cond's, or Bool's About It!

Over time, we've abstracted away the details of the von Neumann architecture first proposed in 1945. GOTOs were replaced with Structured Programming and Functional Programming replaced explicit loops with higher order functions. Immutable values and collections replaced memory address whose contents could change. But one vestige of that architecture remains; using the value of a single bit to determine which code path to take. In this talk, the speaker will report on an experiment to cut this last tie in the design of the Toccata programming language and show what programs without boolean values looks like!

Coding Under Uncertainty

As programmers, we want to write high-quality code that doesn’t contain errors. This means that we need to use a considerable amount of logic in our daily work. But we’re not only programmers, but also humans, and as such, we’re not purely logical. In this talk, we’ll examine in which ways our cognitive biases have a negative impact on the code we write. How can we apply knowledge from psychology to help us enhance our code? How can we gain more self-awareness about error-inducing biases, and turn them into advantages? You’ll leave with practical knowledge about using cognitive psychology to become a better programmer – and a better human!

Type-Level Hold'em: Encoding the Rules of Poker with Shapeless

How can we use Shapeless to model real-world applications? In this workshop, we'll learn how to model the basic rules and strategy of Texas Hold'em poker with Shapeless. Starting with no prior knowledge of Shapeless (or poker!), we'll begin with a discussion of why we would want to model a card game at the type-level and what advantages that can bring us. We will explore how Shapeless encodes mathematical induction in the type system. Using that as a building block, we will learn how to do algebra in the type system. By the end of the workshop, we'll have a type-level verification system of basic poker strategy.

The Keys to Collaboration

Collaboration is the key to creating something better than you can create on your own. That's why there are so many open source projects and we describe our coworkers as our team members. But there is a divisiveness in the tech industry that is doing more harm than good. We separate ourselves from each other more than we try to truly connect, and that has to change. Anyone can be a good collaborator, even if they have trouble communicating. But the key is that you must be open to learning about others and embracing differences. After all, being the same doesn't help us grow; it's being confronted with challenges that forces us to step outside of our comfort zones and view things through others' eyes. In this keynote, the speaker will walk you through why you have a difficult time connecting with others - science is the key here. The speaker will help you understand how you can change your thought processes to better collaborate with members of your team. And finally, the speaker show you how good collaboration and communication can and will help you be better developer.

LambdaConf welcomes you to spend a week in beautiful Colorado, and explore how functional programming can radically improve the way you develop software.

LambdaConf is the one of the largest and most respected conferences on functional programming in the world. With more than a hundred hours of high-quality content from leading practitioners and researchers, LambdaConf will take your skills to the next level, whether you are just beginning your journey or are highly experienced.

More than a just conference, LambdaConf is also a community: a magical place where faraway travelers can come to make new friends, share new experiences, and find renewed hope and passion for writing better software.

We warmly invite you to experience LambdaConf 2016 for yourself. Enjoy mind-blowing workshops and talks. Connect with a passionate and friendly community of like-minded souls. Engage in fun activities and enjoy award-winning local food.

One of the largest, most diverse gatherings of functional programmers in the world

Four action-packed days of workshops, talks, meals, & activities (May 26 - 28)

Fun for the whole family: LambdaConf takes place the same weekend as the Boulder Creek Festival (food, live music, entertainment, crafts) and Bolder Boulder (5k race)

Hosted in picturesque Boulder, Colorado, a mountain town nestled in the foothills of the majestic Rocky Mountains

Free mini-conferences on Wednesday, including PureScript Conf

Commercial training on Monday - Tuesday (Advanced Scala, Spark, Akka, Haskell, etc.)

Free on-site child care, ADA-compliant venues, dedicated unisex restrooms, and more than a dozen volunteers and staff members to assist you and make you feel welcome

Award-winning food catered by local businesses, with no extra charge for special requirements (vegan, vegetarian, paleo, allergen-free)

Pledge of Conduct

LambdaConf is a supportive and welcoming environment, where differences are celebrated, and where people discuss ideas graciously and respectfully, even when they disagree. To help foster this nurturing community, we require that all attendees, volunteers, and speakers make the LambdaConf Pledge of Conduct.

As a participator in the LambdaConf event, I hereby pledge the following:

  • That in the words I speak and the actions I take, I shall demonstrate respect, dignity, and empathy for my fellow human beings; that when I disagree with ideas, I will do so constructively, respectfully, and graciously; and that I will communicate non-violently with empathy and honest self-expression;
  • That I shall embrace and celebrate the abundant diversity in the human species, and refuse to feel threatened by those different from me;
  • That I shall not talk or act in ways that could make minority groups feel bullied, harassed, intimidated, stalked, stereotyped, or belittled; examples of minority groups include women, people of color, lesbians, gays, and people who are disabled, bisexual, transsexual, asexual, intersex, transgender, and gender-variant;
  • That if I become aware of any behavior by others which is inconsistent with this pledge, I shall take immediate action to report such behavior to event organizers;
  • That if there comes a time I no longer wish to keep this pledge, or if I wantonly behave in a manner inconsistent with these promises, I shall immediately cease participation in the event, without expectation of refund or redress.

I hereby acknowledge that my status as participator in this event may be terminated at any time if, in the sole opinion of the event organizers, I have been determined to break this pledge.

NOTE: All LambdaConf staff members will be wearing red t-shirts marked "STAFF", or individuals may text 303-921-5784 with any questions or concerns.


Boulder is a beautiful place to visit in the spring, and a great vacation destination for the whole family. Nestled in the foothills of the Rocky Mountains, Boulder has won numerous awards (foodiest, happiest, brainiest, healthiest, LGBT family-friendly). The city sports a thriving tech scene and a burgeoning community of functional programmers.

Boulder is serviced by Denver International Airport, the largest airport in the United States, and has direct flights from all major US cities and many international cities.

More than a hundred miles of hiking trails, many accessible from downtown

Incredibly low-cost places to stay on Airbnb, starting at $14/night; homes available for groups

LambdaConf discount codes for several hotels, including Marriott, Hyatt, and Boulder Inn ("LambdaConf 2016")

Easy access to Rocky Mountain National Park, Chautauqua, the Flatirons, and other parks

Pedestrian- and cyclist-friendly, with sidewalks, trails, and numerous places to rent bikes

Accessible public transportation system, with major routes running every 10 minutes

Home to the famous Pearl Street Mall, filled with live music, entertainers, cafes, restaurants, and locally-owned shops

Low-cost air fares from Southwest, Frontier, and United; international flights from British Airways and others


Boulder Marriott

1.2 miles away from venue

Hyatt Place Boulder

1.5 miles from venue

Boulder Inn

1.2 miles from venue

To obtain your LambdaConf 2016 special room rates, please call and reference code "LambdaConf 2016".

Schedule and Events

LambdaConf takes place the week of May 22, in Boulder, Colorado. While the actual conference takes place May 26 - 28, the whole week is packed full of activities you may be interested in.

Monday - Tuesday (May 23 - 24)

On Monday, the week kicks off with two full days of commercial training in selected topics.

The following selections are confirmed:

  • Beginning Haskell — LambdaConf is proud to offer two full-days of Beginning Haskell training by Fighting Tanukis (Chris Allen & Julie Moronuki), authors of, the wildly-popular and most accessible book on Haskell programming. This coursework assumes no prior experience in functional programming, and should be accessible to anyone (even non-programmers).

  • Intermediate Haskell — LambdaConf is proud to offer two full-days of Intermediate Haskell training by Fighting Tanukis (Chris Allen & Julie Moronuki), authors of, the wildly-popular and most accessible book on Haskell programming. This coursework assumes a beginning-level familiarity with Haskell programming, and is designed to provide a wide sampling of important concepts and techniques in intermediate Haskell.

If you would like to register for one of these selections, please choose the Corporate Training option when registering. Individuals paying out-of-pocket should inquire for self-pay discounts!

There has been some interest in the following:

  • Advanced Scala Libraries for FP — Training in concepts and usage of libraries such as Shapeless, Cats, Scalaz.

  • Advanced Haskell — Training in advanced concepts and features of modern Haskell development.

  • Big Data Analytics with Spark — Training in using Spark to solve problems in big data analytics.

If you are interested in any of these topics, please contact the organizers using the event registration page.

Wednesday (May 25)

On Wednesday, you'll be able to attend free one-day conferences co-located with LambdaConf!

While not affiliated with LambdaConf, the pizza, coffee, and space are all sponsored by LambdaConf, and the topics were selected because they are relevant to functional programming.

Please see the respective conference websites for information on their Call for Proposals, Code of Conduct, and other relevant information.

  • PureScript Conf — PureScript Conf focuses on the PureScript language and its libraries.

Thursday - Sunday (May 26 - 29)

On Thursday, the official conference begins! You'll enjoy three packed days of workshops, talks, panels, meals, and fun activities.

Finally, Sunday has additional opportunities for group activities, hacking on projects, and unconference sessions.

Kids' Workshops

Count the Dots: Binary Numbers

We can represent words and numbers -- any kind of data -- using only a series of zeros and ones. Computers even store and transmit pictures and sounds using only those two numbers. It's called binary because it only uses two numbers. Let's explore how to count and read messages written in binary.

Twenty Guesses: Information Theory

How much information is there in a book? Is there more information in a phone book or in a novel? How do we measure information? We want to measure information so we know how much space it will take to store it. This workshop will explore ways to measure information.

Lightest and Heaviest: Sorting Algorithms

We often use computers to sort information quickly, putting names in alphabetical order or sorting activities by dates. People have invented many ways to sort a lot of information. Some of those ways are faster than others. In this workshop, we'll explore different methods of sorting to discover why some are fast and some are slow.




Workshops & Talks
Track | Beginner - Room: A115




Opening Remarks and Keynote: Coding Under Uncertainty | Cognitive Bias and Writing Quality Code


Elm 101.5




Functional Algebra for Middle School Students


All About a Fold


Defending Erlang (Through Offensive Behavior)


Afternoon Refresh


Mob Programming: An Experience Report


Revealing Intent: Typed Development in Standard Javascript


Keynote & Lightning Talks


Closing Remarks


Dinner - Mystery Dinner Surprise


End of Day

Track | Intermediate - Room: A108




Opening Remarks and Keynote: Coding Under Uncertainty | Cognitive Bias and Writing Quality Code






Functors, Monads, & More In Scala


Functors, Comonads, and Digital Image Processing


Real-World Gobbledygook


Afternoon Refresh


On the Shoulders of Giants


Purely Functional Semantic and Syntax Expression Composition


psp-std: A New Non-Standard Standard Library for Scala


Typesafe Data Frames with Shapeless


Keynote & Lightning Talks


Closing Remarks


Dinner - Mystery Dinner Surprise


End of Day

Track | Advanced - Room: A104




Opening Remarks and Keynote: Coding Under Uncertainty | Cognitive Bias and Writing Quality Code


Type-Level Hold'em: Encoding the Rules of Poker with Shapeless




Shen Trick Shots


Urbit: A Clean-Slate Functional Operating Stack


Afternoon Refresh


Types for Ancient Greek


Interactive Tests and Documentation via QuickCheck-style Declarations


A Gentle Introduction to Recursion Schemes


Keynote & Lightning Talks


Closing Remarks


Dinner - Mystery Dinner Surprise


End of Day

Track | Alternative - Room: B115




Opening Remarks and Keynote: Coding Under Uncertainty | Cognitive Bias and Writing Quality Code


A Gentle Introduction to Functional Programming through Javascript





Afternoon Refresh




End of Day




Hikes and Other Events


Engineering a Better Twitter






End of Day

Staff and Volunteers

LambdaConf is a 100% independent conference, handcrafted with love in Boulder, Colorado. Each year, the conferences comes together thanks to the passion and hard work of many different people. On this page, you'll learn more about the people who help make LambdaConf such a magical journey for so many functional programmers all around the world.


John A. De Goes

Chief Prophet of Functional Programming

John is the founder of LambdaConf. John would also have you believe his passion and vision for functional programming make him something of a prophet, but really, he's just a bit crazy in the head. Nonetheless, that hasn't stopped John from speaking and writing about FP, introducing FP into many companies, and most recently building a new company around FP languages and concepts.

Courtney De Goes

Head Honcho

Courtney is the amazing event coordinator for LambdaConf, responsible for organizing volunteers, meals, beverages, child care, and a about a million other things. In the few months a year she's not crazy business with LambdaConf, Courtney enjoys lifting weights, and can probably take you in the gym. She also has mad car dancing skills, but you're going to have to take her word on that.

Matthew T. De Goes

Starving Artist / Fed Developer

Matthew is the designer for the LambdaConf brand, conference website, conference signage, and all LambdaConf swag. Despite starting to bald at the tender age of 23, Matthew is really as warm and cuddly as a teddy bear (at least for his wife, baby, and kittens). Rumor has it, he can fix anything with duct tape, though he doesn't have enough hair left to be mistaken for MacGyver.

Sophia De Goes

Dr. De Goes / The Doc

Sophia is the conference's onsite Doctor (M.D.), and assists Courtney in coordinating at the events. As John's better-looking, better-educated, higher-earning counterpart, Sophia spends much of her free time putting up with John's charity work (startups and LambdaConf included). Sophia is an avid runner, weight-lifter, hiker, and skier, and the mother of three impossibly cute children.


Xan Chaves

Video Specialist

Shakra Yves

Video Specialist

Simon Yang

Speaker's Coordinator

Scott Leonard

Pre-Conference Speakers' Coordinator

Rae Macias

Colorado Promotion Coordinator

Paula Lee

Conference Logistics Coordinator

Nate Swanberg

Sponsor Coordinator

Mike Gehard

Industry/College/Meetup Guru

Michael Chavinda

Video Specialist

Karen Blakemore

Dining Coordinator

James Torre

Logistics Knight

Joseph E.S. Cieslik

Sponsor Coordinator

Harpo Roeder

Video Specialist

Gavin Whelan

Dining Coordinator

Brett Hazen

Meetups Coordinator


You need to go. Best conference I've been to in several years. Yes, including StrangeLoop.


This weekend at LambdaConf was amazing in every imaginable way. Best. Conf. Ever. Thanks to all the staff! See you next year!


Pretty sure LambdaConf was the best conference I've been to. Mentally challenging, engaging and made me excited to program (and learn) again.


LambdaConf was amazing. Thanks to all the organizing staff for working so hard. Packed with content, yet beginner friendly and welcoming.


Ah, an awesome LambdaConf! so much food for thought, going to be thinking about this for months. Amazing talks and workshops!


Fantastic weekend at LambdaConf. Met some amazing people, well done to @jdegoes and rest of the staff on an event well done.


Last year I ended up being just a bit late to for Strange Loop tickets. Can't let that happen for LambdaConf, my current favorite conference


LambdaConf is all sorts of awesome - met lots of people, interesting discussions, informative workshops/talks. Absolutely amazing.


If you go to only one conf in 2016, make it this one.


Thank you for an AMAZING conference! Top notch! Truly awesome!


Feels like early Christmas - the LambdaConf 2015 video recordings were posted for early access backers! Can finally review the brilliance.


The 2015 LambdaConf art was too amazingly beautiful to not frame.


I had a great time LambdaConf 2015! Amazing talks and discussions of functional langs, plus hiking in beautiful Boulder!


The @elmlang workshop by @rtfeldman was a great wrap up to the amazing LambdaConf conference. Thanks to all who made both possible.


Bought my ticket for LambdaConf. Excited to attend again this year.


It's only my third conference ever, but LambdaConf has also had the best talks and workshops of the conferences I've been to.


LambdaConf was the best experience I've had at a conference. Thank you @jdegoes and everyone else for putting it together.


Epic, loved @puffnfresh's Idris workshop, mind-blowing wake up call. Whole thing reminds me of @strangeloop_stl in the best way


Really amazing how far LambdaConf has come in 12 months. Too many highlights to list.


Just submitted to LambdaConf: great conference, great people, great location!


I pouted last year then regretted not going to StrangeLoop. However, I think LambdaConf is quickly overtaking StrangeLoop as my favorite.


Just registered for LambdaConf 2016. Looking forward to more excellent talks and people this year!


Can we have LambdaConf this month, or do I really have to wait till May?


Yet again, LambdaConf delivers an amazing round of great presentations. Can't wait until next year!


Bye-bye, Colorado. It was an awesome experience at LambdaConf. I hope I'll see you all next year.


I've recorded more than 50 tech conferences. LambdaConf is 1 of 3 to provide daycare for its attendees w/children. How awesome is that?!!




We're proud to be returning to the University of Colorado Boulder, for the third year in a row. All events, including commercial training and the mini-conferences that precede LambdaConf, will be held at the Jennie Smoly Caruthers Biotechnology. The building is bright, beautiful, spacious, and ADA accessible.


Please click here to obtain a parking pass. LambdaConf is listed under general events or can be found by searching for Lambda Conference.

Connect with Us

News Feed

Follow us on Twitter for the latest news.

Stay in Touch

Subscribe to our newsletter to be kept up-to-date on LambdaConf, to receive notification when we post videos from recorded talks, and to get special discounts on events.

* indicates required
Get Local

Join or start a LambdaConf Outpost to learn and share on all topics related to functional programming.

Art of LambdaConf

Widely cited for its distinctive visual style, LambdaConf 2015 featured the introduction of the hand-illustrated fire unicorn, along with posters, t-shirts, and stickers that attendees raved about.

This year, the artist behind LambdaConf, Matthew De Goes, has poured even more time and energy into creating a beautiful set of stickers, an original poster, and all-new t-shirt designs.

On this page, you can get a sneak peak at some of this work, and go behind-the-scenes to see the making of this year's iconic poster. Enjoy!

Conference Poster

Watch as the LambdaConf 2016 poster comes alive, from its very first pen strokes.

Collectible Stickers

Take a look at some of the early concept art for the collectible stickers.

LambdaConf Poster

Finally, preview a few of the actual sticker designs attendees can find in their swag bags!

LambdaConf Poster
LambdaConf Poster
LambdaConf Poster
LambdaConf Poster

LambdaConf 2016 Sponsors






Disclaimer: LambdaConf does not endorse the goods, services, views, behaviors, or values of any sponsors, nor those of any individuals under the employ or association of any sponsor (except, go buy a copy now!). We do, however, endorse taking sponsor money and using it to help the world find better ways of writing software.