Intro Sponsors Schedule Travel Venues Register Speakers Discuss

LambdaConf 2015

Bigger, Better, Boulder

May 22-24 - Boulder CO

Ignite your functional programming skills

“It was awesome. Be sure to go next year!”


“I just wanted to say this explicitly: #LambdaConf was amazing.”


“Very well organized; great speakers with thoughtful talks. Lots of challenging material for me. Brain full.”


“So much awesome at #lambdaconf!”


“Paul Phillips presentation at LamdaConf is one of the best I've seen in a long while.”


“On a bus headed home from #lambdaconf. I have tons of things to research and met a bunch of awesome people.”


“Really good to meet so many smart people at LambdaConf. Great conference!”


“Inspired to demand more of our tools and that we can do better after #lambdaconf.”



Ignite your functional programming skills at the second annual LambdaConf — the largest interdisciplinary functional programming conference in the Mountain West.

With more than 40 speakers and two and a half days worth of content, LambdaConf brings together attendees with a diverse set of skills and backgrounds, united by a common passion for the power of functional programming.

Students, researchers, and programming professionals of all persuasions will find relevant topics, including introductory material on functional programming, PL and type theory, industry case studies, language workshops, and library tutorials.

In addition to two and a half days of content, the conference has ample opportunity for networking, including five group meals, one drink social, one group activity (hiking or tea), a half day unconference, and unscheduled time Saturday evening.

  • 2.5 Days of Fun. Hands-on workshops, lightning talks, presentations, awesome food, fun activities, and loads of professional networking in beautiful Boulder, Colorado. Come early and stay late!
  • Beginner-Friendly. Specially-prepared workshops and talks help beginners learn the basics of functional programming: what it means, why it's useful, and how to think functionally.
  • Discover Boulder. While you're in town, attend the highly-acclaimed Boulder Creek Festival for entertainment, dance, music, food, and crafts. Hike one of dozens of trails in walking distance from downtown. Participate in or watch Bolder Boulder, America's all-time best 10K race. Hang out in downtown Boulder for great coffee, amazing food, street performers, and much more. Take a stroll down the Boulder Creek Trail. Finally, enjoy the sunny, beautiful weather that Boulder is famous for!
  • Awesome Local Food. We are pleased to feature some of Boulder's highly-rated local cuisine for all meals! Food requirements or allergies? No problem, just let us know and we'll have something special made just for you.
  • On-site Daycare. Check your kids into our on-site daycare, available for all events. Then check them out and take them to Pearl Street Mall, the Boulder Creek Path, or the mountains — all of which are in easy walking distance from the conference.
  • Welcoming. The main venue is ADA compliant and has two single-stall, all-gender restrooms. If you have any special needs, just let us know during registration, and we'll do our best to help out.
  • Responsive. LambdaConf will have six volunteers and four staff on-site, all wearing clearly marked apparel. Every attendee will be able to text conference staff directly with any questions, comments, or concerns.


Daily Schedule

Clear here to access the daily schedule. Bookmark the link, as last minute changes will be noted in this schedule!


The Art of Meaningful Connection: A Fear-based Approach to Communication Sharon Steed

We spend all day communicating with people - verbally, nonverbally, on social media, over the phone, and in a myriad of other ways. But have you noticed that even though we are always connected to people, we aren't every really connecting with people? As a stutterer I know the struggle to effectively get your point across, especially in a time-crunched society. We as humans are rushed, rarely patient and generally in transit to the next thing. And I understand; I spend just as much time flying through the day as the next person. But I also understand the value of human interaction, and the fear that comes along with the idea of it. I've tried - and failed - at having meaningful conversations many times because of fear that I won't be accepted for who I am. But once I opened myself up to potential rejection, I ended up being accepted and celebrated for being flawed.

Let's explore that fear together: the fear of reaching out, of real conversations and of willingly extending our hand to others looking to truly connect with us. Our weaknesses are often times great compliments to our strengths; it's time to be inspired to embrace vulnerabilities, empower our weaknesses and truly connect with the human beings around us.

Ipecac for the Ouroboros Paul Phillips

"Compatibility means deliberately repeating other peoples' mistakes," said Wheeler. Not only a pithy aphorism, but literally true. And today, almost fifty years after the birth of unix, we still make it a point to deliberately repeat mistakes - even if we don't count unix itself among them. Why do we still program to teletypes? Why must we concern ourselves with newlines in file names? Why is it still an everyday occurrence to find the arrow keys don't work? Why did scala intentionally repeat most of java's mistakes? How is it that so much effort is poured into validation of inputs, yet it's never enough? How can it be that we know the benefits of types, yet only enjoy those benefits in a minority of environments? Why is it so difficult to clamber above the maelstrom of complexity - and stay there?

Can't we have it both ways - make improvements without sacrificing compatibility?

In fact, we can have it both ways. The subject of my talk is the almost unexplored frontier through which we can disrupt the endless perpetuation of mistakes of the past: ipecac for the ouroboros.

Lightning Talks

Haskell Hole-driven Development with GHC-mod Alejandro Serrano Mena

Types in functional programs are not only means to verifying and documenting our code, they can also help in writing them! This way of working is usually termed "hole-driven development". The reason is that you annotate those parts of your program which still need to be written with "holes". Afterwards, you can query the compiler and interact with your code until no hole exists. In some cases, the code can be automatically written for you.

Hole-driven development environments are available for many languages, including Agda, Idris and Haskell. In this talk we will look at a practical example of this methodology using Haskell and its Emacs mode enhanced with the ghc-mod add-in. Get ready to unveil the hidden power of types!

AllCode Literacy is Literacy Too Gershom Bazerman

There is a large body of literature on teaching writing. There is comparatively less on teaching writing computer programs in particular. If we treat “code literacy” as a form of literacy, what knowledge and insights can we transport over into our domain, and what shibboleths can we dispel?

Erlang Feel the Rush: CRDTs in Riak Zeeshan Lakhani

Reconciling conflicts in eventually consistent distributed systems can be messy adventure, but conflict-free replicated datatypes (CRDT’s) offer a solution where updates are accepted without remote synchronization and replicas properly converge into an equivalent state. Riak Data Types bring CRDTs to the server side, making data modeling simpler and skipping the need to roll your own conflict resolution logic. More than anything, these data types make some of the recent research in strong eventual consistency real and practical, and I’ll demo #howitdoesit.

Haskell An ARM-Powered Musical Instrument Using Haskell Ben Burdette

A presentation on the Cyclophone, which is an instrument that uses Haskell internally for its control logic. The instrument will be at LambdaConf so people can play with it. This talk will briefly cover the tools Ben used and the various obstacles that came up during the project.

Haskell A Microservices Architecture with Haskell: An Experience Report Phil Freeman

At DICOM Grid, we have been using Haskell as part of a microservices architecture lately with some success. I would like to share some experiences of the highs and lows of using a relatively novel language in production, and give some tips for other potential adoptees.

Haskell Results from using Haskell in Scientific Computing Alex Gremm

Due to the high demand for performance, programs in the Scientific Computing community are usually written in Fortran or C/C++ for execution on CPUs and in CUDA when GPUs are targeted. Though, why not use Haskell and see where it stands? We will take a quick look at code complexity and performance results of the implementations of a simple diffusion algorithm in Fortran/CUDA and Haskell.

Scala Trampolines and Lifting: AKA Save Your Stack Vincent Marquez

We all know that making a method tail recursive is one way to ensure you don’t SOE when recursing. However, sometimes it’s either not possible or convenient to make your methods tail recursive, and this is where trampolining can help. Beware though, his is not always a solution, for instance when using a Monad Transformer stack. This is where the Free Monad can come to the rescue, and we’ll take a look at examples of both trampolines working and not working, as well as using Free in a non trampolined way to save your stack


Haskell LiquidHaskell: Refinement Types for Haskell Ranjit Jhala

Haskell has many delightful features, perhaps the most beloved of which is its type system which allows developers to specify and verify a variety of program properties at compile time. However, many properties, typically those that depend on relationships between program values are impossible, or at the very least, cumbersome to encode within Haskell's type system. Refinement types enable the specification and verification of value-dependent properties by extending Haskell's type system with logical predicates drawn from efficiently decidable logics. In this talk, we will start with a high level description of Refinement Types. Next, we will present an overview of LiquidHaskell, a refinement type checker for Haskell. In particular, we will describe the kinds of properties that can be checked, ranging from generic requirements like like totality (will 'head' crash?) and termination (will 'mergeSort' loop forever?), to application specific concerns like memory safety (will my code 'SEGFAULT' ?) and data structure correctness invariants for various libraries like containers, hscolour, bytestring, text, vector-algorithms and xmonad.

Rust An Introduction to Rust: Or, "Who Got Types in My Systems Programming!" Jared Roesch

This workshop is intended to be a deep dive into Rust starting from the very basics to advanced type level programming. Rust is a new experimental programming language currently being designed by Mozilla Research and the language's active community. The language is inspired by several variants of ML, Haskell, C++, as well as novel research ideas about the performance and safety of programming languages. One of the key features is the reification of memory as an explicit part of the language semantics. This provides low level control of memory allocation without sacrificing the safety of garbage collection. The goal of this workshop is to show how we can use Rust to write high level code that provides excellent safety and performance.

Haskell The Art of Program Derivation and Parallel Computation Gershom Bazerman

Program Derivation is the practice of beginning with a specification of a function, and by a series of mechanical steps, deriving an efficient implementation. In the “Algebra of Programming” approach, pioneered by Richard Bird, Oege de Moor, and Lambert Merteens, we can derive efficient functional programs by a series of algebraic manipulations, much schoolchildren can take a typical algebraic function, “solve for x” and then simplify. In the early-mid 90s, this school of research turned its attention to the problem of parallel computing and developed many of the foundations for what is now called MapReduce. This workshop will run through some famous and nifty algorithms and derivations, parallel and sequential alike. Attendees should walk away with a few weird tricks to level up their equational reasoning in everyday programming contexts, and hopefully enough intuition to dive more deeply into this rich body of literature.

PureScript Learn Functional Programming with PureScript John A. De Goes

This workshop is designed for programmers of any skill level who want to learn functional programming. PureScript is ideal for learning functional programming, because the language has simple, clean semantics, and runs on any platform because it compiles to ubiquitous Javascript. In this workshop, you'll learn what it means to think functionally and write functional code as you explore the core concepts in PureScript. By the end, you'll have written your first functional program (a simple game!) and be able to call yourself a rookie functional programmer.... or else the instructor promises to buy you a coffee!

Haskell Modeling Data in Haskell for Beginners Chris Allen

There are patterns for modeling data that are not obvious or widely covered in Haskell that only require the application of basic algebraic datatypes, we'll explore some of these approaches with the dual purpose of introducing thinking in terms of algebraic datatypes in Haskell. The audience is not expected to know Haskell.

Any Conversation 201: What Stuttering Can Teach You About Talking to Humans Sharon Steed

Developers are trained to communicate to things with a goal in mind. When you're talking to something like, say a computer, you type in your code and it responds by giving you back what you want. Nine times out of ten, it works perfectly. Why, then, is it so difficult to do this same thing when talking to a client about a project, updating a superior on your progress, or pitching an investor your million-dollar idea? Because talking to people requires a special set of skills - namely, empathy and a little bit of storytelling. In an industry filled with brilliant minds, great ideas and mass disruption, so few of the best and brightest know how to tell their compelling story. The takeaways from this workshop will be learning how to value the listener and use vulnerability to improve your social connection.

Prolog Introduction to Constraint Logic Programming Sergii Dymchenko

Constraint logic programming is a paradigm that allows solving hard combinatorial problems with minimal programming effort. In this workshop you will learn the basics of the Prolog-based constraint logic programming system ECLiPSe, solve several puzzles, and get hints how constraint logic programming can be useful in your real-life projects.

Haskell A Practical Introduction to Haskell GADTs Richard Eisenberg

A burgeoning Haskeller soon discovers that proper use of descriptive types helps to capture real-world ideas, catches errors, aids in refactoring, speeds development, and indeed makes programming more fun. But, once that Haskeller has drunk the well-typed Kool-Aid, where to go from there? The answer: even more types! A Generalized Algebraic Datatype (GADT), at its core, allows a compiler to make different assumptions about types within different branches of a pattern match. Leveraging this power allows a programmer to encode detailed invariants in a datatype or algorithm and have these invariants checked at compile time. Clever use of GADTs also lets you remove certain uses of unsafeCoerce, as long as these can be proved safe. This workshop will be a hands-on, interactive tutorial on using Haskell GADTs in a practical setting.

F# Freya (F#) for HTTP Systems Andrew Cherry

Freya is a stack of libraries for F# which are designed to let you get close to HTTP in a functional, typed way. As well as providing a useful set of abstractions over HTTP, it also offers a graph based approach to modelling HTTP responses, enabling the creation of "well-behaved" HTTP applications simply (and correctly). We'll take a tour through the stack and exercise the various parts individually, before diving in to write a complete HTTP application. We'll see how easy it is to write applications which take full advantage of the HTTP standards, and then we'll look at ways of extending our application out past the world of RFCs in to the world of hypermedia - and we'll do it with graphs! After this session you'll be comfortable building an application using Freya, and you'll almost certainly have come up with some great ideas for how Freya, and the graph based approach to logical design, could be extended to do even more.

All Introduction to Clojure: The Programming Language You've Been Longing For Paige Bailey

Grab your REPL and your prettiest pair of parentheses! In this beginner-friendly workshop (even if you've never coded before), you will learn how to think in Clojure, why you would want to, and you'll get the opportunity for some hands-on experimentation with Zach Oakes' Nightmod, a developer tool for making live-moddable games. Clojure is a relatively new, powerful, dynamic Lisp dialect that compiles to many target environments, including the JVM, JavaScript, and the CLR. The most important single principle behind Clojure is its simplicity: its abstractions are simple and orthogonal, which means no compromise on power. A la carte polymorphism, careful support for names and namespaces, the reference succession model, and a wide selection of small, composable protocols make Clojure programming swift, surgical, and accurate. Perfect for game development! So are you ready, brave programmers? It's time to get atomic!

ClojureScript Data-Driven Webapps with ClojureScript and Om Chandu Tennety

Om is a flavor of Facebook's ReactJS that takes advantage of immutable data structures to make the virtual dom-diffing algorithm much faster in the ClojureScript environment. We will work through some simple examples to get an understanding of how state is represented and passed through to components in order to build fast, functional UIs.

Haskell Developing Web Applications with Haskell Alejandro Serrano Mena

Web development is easy and fun with Haskell... and of course, type safe! Let's take a birds-eye tour on creating a web application in Haskell from scratch, from the initial project creation to deployment in the cloud. By the end of the workshop, you will have deployed a small server for note-taking. The workshop is divided in four slots, each dealing with a different facet of web development. First of all, simple routing and building of HTML to be returned to the clients. Then, adding database capabilities using Persistent and Esqueleto. The next step is taking input from the user via digestive functors. Finally, deployment to Heroku will be considered, along with integrating other middleware in your application.

Elm An Adventure in Elm: Writing an Adventure Game in Elm Joe Nash

Elm is a functional reactive language that compiles to HTML, CSS and Javascript, with Haskell-like syntax. Thanks to a combination of smart language design and innovative web-based tools, it is incredibly easy to write interactive applications in Elm. During this workshop we'll cover the basics concepts of the language and syntax, dive into the hot-swapping editor and time-travelling debugger, and build an adventure game using functional reactive technqiues.

PureScript Purely-Functional Web Apps using React and PureScript Phil Freeman

React has popularized the idea of user interfaces as pure functions of application state, an approach which is perfectly suited for a language like PureScript. In this workshop, we'll learn how to use React and PureScript to create clean, well-factored web applications. This workshop assumes only basic knowledge of PureScript (or a related language such as Haskell), and for that reason, it can be considered a continuation of the earlier PureScript workshop for beginners.

Haskell Introduction to Haskell with a focus on High-Performance Computing Alex Gremm

This workshop will give an introduction to the Haskell programming language. We will work through basic concepts of functional programming and specifically Haskell by implementing a simple diffusion algorithm with convergence check. Using our naive implementation, we will learn how to identify performance bottlenecks and how to overcome them in order to achieve high-performing, sequential code.

Erlang Introduction to Erlang Steven Proctor

If you have heard nothing else about Erlang, you have probably heard something about OTP and people chanting “Processes are not threads. Processes are really cheap. Ohmmmm.” In this workshop you will get a overview of Erlang syntax, OTP process management, and how cheap Erlang processes really are when you implement a Markov Chain generator where each state and its possible transitions are represented by their own process.

Cryptol Intro to Cryptol and High-Assurance Crypto Engineering Adam Foltzer

Cryptol is an open source pure functional language for expressing and reasoning about bit-precise computations, particularly cryptographic algorithms. Like Haskell, it is built upon a polymorphic, static type system, and offers similar mathematical function and sequence comprehension notation. The type system features size polymorphism and arithmetic type predicates designed to express the constraints that naturally arise in cryptographic specifications.

The advanced type system and restricted domain of Cryptol enables a theorem-driven development style: correctness properties can be expressed directly in the language in tandem with the development of a specification. As the specification evolves, these properties can be continually fuzz-tested with random QuickCheck-style testing, and even sent to external SAT and SMT solvers for a mathematical proof of correctness.

In this workshop, I’ll give a quick introduction the Cryptol language geared toward folks with a working knowledge of typed functional programming. Together we will implement a classical cryptosystem to learn the basic syntax and semantics of the language. As we program, we will express and check correctness properties about our implementations using QuickCheck and SMT. Finally, I will demonstrate a Cryptol specification of the ZUC stream cipher used in 4G LTE communications, and show how the theorem-driven development approach reveals a bug that required a revision of the cipher.

Typed Racket Introduction to Typed Racket Mark Farrell

This workshop will give an introduction to Typed Racket. We will give an overview of the features of its type system, go over some examples of typing old untyped Racket code and provide some accompanying typing exercises for people to try. We will also discuss some current issues trusting Typed Racket, e.g. sketchy examples of mixing typed and untyped code. Finally, we will discuss the need to add type annotations to a significant number of existing Racket modules - and try to get people interested in contributing to Typed Racket. Some prior experience using a Lisp-like functional programming language, such as Scheme/Racket, could be an asset in understanding the content of this workshop, though none is required.

Idris Write Some Idris Brian McKenna

Idris is a dependently typed programming language. Unlike most other dependently typed systems, Idris is designed specifically for writing executable programs. This workshop will slowly walk through writing a few programs using dependent types, to motivate its uses around correctness and expressivity.

This workshop will be modeled similarly to LambdaConf 2014's but with new examples to demonstrate what Idris is capable of. The only prerequisite knowledge is familiarity with algebraic data types. It is important to have the Idris REPL installed, optionally with an interactive editor configuration such as Emacs' idris-mode or Vim's idris-vim.


Emily Introducing Emily: Simplifying Functional Programming Andi McClure

Emily is an experimental language project focusing on simplifying the basis of programming languages: it models all language operations through composition of function-like entities, equivalent to combinators with state. This means functions, objects, classes, and variable scopes have the same interface and are generally interchangeable. The goal is to make FP language capabilities accessible to entry-level and FP-wary programmers by means of simple concepts and a configurable, scripting-language-like syntax.

Haskell Building Secure Systems in Haskell Deian Stefan

Modern applications—in particular, web apps—handle user-specific, often sensitive, information. Unfortunately, protecting user data is notoriously difficult today—languages and frameworks do not provide a way for declaring and enforcing application-specific security policies. In response, developers often specify and enforce security policy in an ad-hoc fashion (e.g., by strewing security checks throughout the code-base). Even if one manages to get all the checks in all the right places, applications rely on third party libraries which may themselves expose vulnerabilities (or, in some cases, happen to be malicious). Recent headlines alone serve to highlight that existing approaches are not working—web applications are plagued by privacy leaks. In this talk I will first describe LIO, a Haskell library for building secure systems. LIO is an information flow control (IFC) library—it provides APIs for specifying policy on data (who is allowed to read/write the data) and enforces this policy on all code leveraging Haskell's monads and strong type system. I will then describe Hails, a web framework built on top of LIO that makes it easy to specify policies in a declarative way, when defining your application data types. Hails applications, by construction, protect user privacy and integrity.

Haskell Haskell Nuggets: Power Series Brought to Life Doug McIlroy

Operations on power series showcase the elegance and expressiveness of overloading and lazy evaluation. Simple one-liners for sum, product, integral, derivative, functional composition, functional inverse, etc. vividly embody the underlying mathematics, and even improve upon it by banishing subscripts. Series solutions of differential equations come practically for free and generating functions actively generate.

Scala What's New in Scala Marconi Lanna

"Programming in Scala", by Martin Odersky et al., is one of the most comprehensive and the de facto reference for Scala. However, the book, originally published in 2008 for Scala 2.7.2, has not been updated since its second edition in 2010, covering up until Scala 2.8.1. In the meantime, Scala has had 3 major releases with numerous fresh and advanced features. While we wait for a third edition of "Programming in Scala" to describe all the latest and greatest Scala features introduced in the last 4 years, this talk presents the main features introduced in Scala: 2.9, 2.10, and 2.11, as well as an exciting peek into 2.12 and beyond (What's in Scala's future?).

None The Virtual Filesystem: This Changes Everything Paul Phillips

In this talk, Paul Phillips expands on ideas in his keynote to deliver a compelling vision for how properly conceived and implemented virtual file systems have the ability to literally change every single thing about how we interact with computers.

Scala A Skeptic's Look at Scalaz "Gateway Drugs": A Practical Exploration Brendan McAdams

We've all seen them on the corner of our local software development neighborhoods: FP purists, shamelessly peddling scalaz to unsuspecting developers. Lured in by promises of Free Monoids, Semigroups, and Endofunctors these developers soon seem lost in throes of ecstatic coding.

To the skeptical and stubbornly practical among us, the above might ring a little true – especially if read in Rod Serling's voice. Images of gibbering horrors lurking in the depths of mathematical perfection swim before our eyes.

But what if there is true value in the world of Scalaz? What if it is possible to use these tools for good (and a little bit of evil – it's fun to use learning for evil!) and profit... Without getting hopelessly lost in the opium dens of FP?

In this talk we will look at some of the "gateway drugs" of Scalaz: Validation, NonEmptyList, \/, Monad Transformers, and more. How do they work from a practical standpoint? What is their value for real world applications? Can we use them without an advanced Maths PhD? And just how fun is it to really code with these tools?

Haskell Pattern Functors: Wandering Around Fix-points, Free Monads and Generics Alejandro Serrano Mena

Free monads, generic programming, fix-points and coproducts of data types are usually considered advanced topics for a Haskell programmer. In this talk we will look at these concepts from an unifying lens: combining and enriching pattern functors. A pattern functor is the stripped-down description of a data type: only the shape of the constructors remain, but all the recursive structure is gone. Using Haskell, we can manipulate pattern functors to create new data types at will.

Various Why I Like Functional Programming Adelbert Chang

Shortly after Adelbert Chang entered college as a computer science major, he contemplated changing his major several times, usually in the direction of physics and mathematics. That all changed when he was introduced to functional programming — at once both mysterious and beautiful. In this talk, Adelbert will elaborate on his early perspectives on computer science, math, and physics, and discuss how he ended up so enamored with functional programming.

Scala Axle: A Spire-based DSL Adam Pingel

Axle is a Scala-embedded domain-specific language built on Spire. This talk will cover the architecture and objectives of the project. Live coding examples will show how "design patterns" from Abstract Algebra apply to a range of domains including machine learning, bioinformatics, game theory, statistics, and data visualization.

Various Selfish Purity: How Functional Programming Makes Every-Day Jobs Easier Daniel Spiewak

Functional programming is too-often viewed as an academic discipline. And why not? After all, FP imposes constraints that seem to be more aesthetic and pedantic than practical, and almost all motivating examples for FP involve one-liners mapping over a list while hand-waving about endomorphisms rather than something more "down to earth". This talk takes a different approach.

Functional programming makes things easier. It makes it easier to write code, test code, design components and abstractions. It makes turnaround times faster, bugs rarer and even improves application throughput. This talk explains how all of this is possible and why it is precisely that I will never work on a serious application without FP again. We will also touch briefly on how FP works (or doesn't work) in common industrial languages like Java and JavaScript, and where we can gain benefits by expanding our toolset just a bit.

Erlang Fault-Tolerance on the Cheap: Making Systems That (Probably) Won't Fall Over Brian L. Troutwine

Building computer systems that are reliable is hard. The functional programming community has invested a lot of time and energy into up-front-correctness guarantees: types and the like. Unfortunately, absolutely correct software is time-consuming to write and expensive as a result. Fault-tolerant systems achieve system-total reliability by accepting that sub-components will fail and planning for that failure as a first-class concern of the system. As companies embrace the wave of "as-a-service" architectures, failure of sub-systems become a more pressing concern. Using examples from heavy industry, aeronautics and telecom systems, this talk will explore how you can design for fault-tolerance and how functional programming techniques get us most of the way there.

None The Abstract Method, In General Gershom Bazerman

“Programming is about abstraction.” But what is abstraction about? Surely not just programming. Why do we need it, why do we keep reinventing it? How do we even recognize it when we see it, across so many domains? When something is more abstract, it is not necessarily more useless, even though, definitionally, it is further removed from any specific use. How can that even be the case? Too often, when we teach functional programming, we are met with the response “you have taught me some abstractions, but not what they are good for.” Certain realms of mathematics, such as category theory, often elicit similar responses. This talk is an investigation into how to consider not only abstractions, but the process of applying them.

Any The Next Great Functional Programming Language John A. De Goes

John has no clue what the next great functional programming language will be like, but he's more than happy to hop up on stage and rant against type classes, nominative typing, data, modules, pattern matching, recursion, and, well, basically everything else you associate with functional programming! John will argue that to make radical progress in cheaply building correct software, we need to take one step backward and two steps forward, embracing dependent-typing, total functions, Turing-complete compilers, host languages, and automated proof search. Attend this talk to question your assumptions about functional programming... or just to heckle! Either way, all are welcome.

Elm Shipping a Production Web App in Elm Richard Feldman

What happens when you take a 2011 CoffeeScript web app designed to edit 100,000-word novels...and scratch-rewrite it in Elm? It turns out the result is faster, more robust, and massively easier to maintain. Elm's simple design means that even a functional programming novice can quickly get up to speed on its static type inference, pervasive immutability, and first-class FRP system. It's not only an excellent language, but also a great introductory FP language that any JavaScript developer can pick up. This talk dives into the nuts and bolts of shipping a production web app in Elm, including questions like why you should choose Elm, how you transition from imperative architecture to FRP, and to what extent you can leverage the JavaScript library ecosystem without sacrificing your functional invariants. Come see how pleasant functional programming in the browser can be!

Scala Idiomatic Scala: Your Options Do Not Match Marconi Lanna

The Scaladoc page for Option says: "The most idiomatic way to use a scala.Option instance is to treat it as a collection or monad and use map, flatMap, filter, or foreach [...] A less-idiomatic way to use scala.Option values is via pattern matching." In this talk we show how to use the Option monad in an idiomatic, functional style, leveraging its comprehensive set of higher-order functions to solve any coding situation in a concise and declarative manner. After this talk, you will never have to pattern match against Options again!

F# Building Concurrent, Fault-Tolerant, Scalable Applications in F# using Akka.Net Riccardo Terrell

Writing correct concurrent, fault-tolerant, scalable applications is no simple task. The struggle is generally the result of using the wrong tools or wrong level of abstraction. The Actor based concurrency model aims to simplify this process. The actor model is a mathematical model of concurrent computation originated in 1973 by Carl Hewitt, Peter Bishop, and Richard Steiger. Actor programming is one of the most widely applicable programming models, which provides support for concurrency, by improving distribution, error detection, and fault tolerance. As such, it’s a good fit for the kinds of programming problems we find ourselves faced with in today’s increasingly distributed world Actors raise the abstraction level and provide a better platform to build correct concurrent and scalable applications. This presentation will introduce concepts in architecture such as immutability, isolation and asynchronous processing utilizing tools such as Akka.NET which is a .NET port of the popular JVM framework Akka. The goal is to provide solid knowledge of and foundation for the Actor model. Following the presentation, attendees will take with them enough material to start to use and leverage the Actor model to write successful concurrent applications.

Haskell Accelerating Haskell: GPGPU Programming with Haskell Joe Nash

Many machines and devices come equipped with powerful graphical processing units, or GPUs. These units have hundreds of processing cores, and can be exploited to accelerate our applications by offloading applicable code to the GPU instead of the CPU. In this talk we will cover the basic concepts of General Purpose Programming for GPUs, and show how it can be exploited in the functional programming language, Haskell, via the accelerate library.

Scala Programs as Values: Pure Composable Database Access in Scala Rob Norris

FP is often glibly described as "programming with functions", but we can equivalently say that FP is about programming with values. Functions are values, failures are values, effects are values, and indeed programs themselves can be treated as values. This talk explores some consequences of this idea of programs-as-values by looking at doobie, a pure-functional database library for Scala. We will examine the low-level implementation via free monads over algebras of the JDBC types, and show how this naturally enables an expressive and safe high-level API with familiar, lightweight, and composable abstractions including streaming result sets, and trivial compatibility with other pure libraries like Remotely and HTTP4s. Even if you are not in the market for a database layer, this talk will provide a practical outline for a general solution to dealing with terrible APIs (like JDBC) in a principled way.

Various Make Up Your Own: "Hello World!" Justin Campbell

There are so many other languages out there, and they all have strengths, weaknesses, and very different communities surrounding them. How do we evaluate new languages and technologies for ourselves? How do we be pragmatic about introducing things to production? Let's talk about language exploration. We'll discuss how to learn a new language, considerations when introducing things to production, and come up with some ideas for Ruby and its ecosystem. Plan on dipping your toes in Elixir, Go, Haskell, Ruby, Rust, and Scala during the session.

Lisp-Flavored Erlang The Meaning of LFE Zeeshan Lakhani

Do you enjoy Lisp-based languages, built on s-expressions and homoiconicity? Do you like writing syntactic abstractions with pattern matching? What if you could use a Lisp to write a fault-tolerant, highly-available distributed datastore? Welcome to the wonderful world of LFE (Lisp-Flavored Erlang)! I'll cover the basics of LFE, its toolchain, the macro system, and its intermediate representation step to Core Erlang, ending up on BEAM, the Erlang virtual machine.

Scala Scalaz 102 - Level Up Your Scalaz Foo! Colt Frederickson

Scalaz is a massive library full of many critical FP abstractions, but it can be a bit dense. If you've dipped into Scalaz for a couple things such as Either and Validation, but you're not sure what else you can use, this talk is for you!

Haskell How to Learn Haskell in Less Than 5 Years Chris Allen

Haskell is known for being hard, this is a result of pedagogy catching up to different ways of thinking about and structuring programs. We can make teaching ourselves and others something that is not only more effective, but enjoyable in its own right.

Your Imagination Make Your Own Programming Language! Nick Heiner

We're all used to typing code into an editor and seeing the computer do something when we run it. This is so familiar that it's easy to take for granted. How do we go from a sequence of characters to something the machine can execute? Knowing this will not only help you program more effectively, but it will empower you to create your own programming languages.

I'll give an overview of the pipeline from your text editor to the machine's behavior. Then, we'll dive in and look at specific tools that will help us create our own programming language. We'll also discuss different language design decisions, such as static versus dynamic typing, and see how they are implemented behind the scenes.

By the end, you'll be ready to bring your new language into the world!

Clojure Loom and Functional Graphs in Clojure Aysylu Greenberg

Graphs are ubiquitous data structures, and the algorithms for analyzing them are fascinating. Loom is an open-source Clojure library that provides many graph algorithms and visualizations. We will discuss how graphs are represented in a functional world, bridge the gap between procedural description of algorithms and their functional implementation, and learn about the way Loom integrates with other graph representations.

Clojure/Clojurescript Full-stack FP in Datomic, Clojure, and ClojureScript Priyatam Mudivarti

What happens when we prototype an app entirely in FP?

From choosing a functional database to building http apis and designing templates and stylesheets—it is possible these days, to stay entirely in FP land! In this talk I will share my experience in building functional prototypes with Clojure & Clojurescript using the following libraries: Datomic, Ring, Om, and Garden. I’ll discuss how we can trade popular databases, web toolkits, template engines, and even less and sass in favor of simpler libraries that embrace immutable data as a “Sequence of Values”.

None Dynamic vs. Static: Having a Discussion without Sounding Like a Lunatic David Greenberg

Types remain a highly contentious issue for programmers in industry. Rails and Python have massive communities, and drive high-profile, high-traffic, successful businesses, such as GitHub, Reddit, and Dropbox. Clearly, dynamic languages are a better choice than Java or C; unless, of course, we count the myriad more businesses powered by 90s statically typed languages (e.g. Java). This statement will infuriate some engineers and academics, as we all know that Hindley-Milner type systems are the only type systems that reduce defects and improve code quality. In this talk, we'll take a look at type systems through a different lens: how type systems are actually a business decision that is frequently cast as an emotional decision.

None Type Theory and its Meaning Explanations Jon Sterling

At the heart of intuitionistic type theory lies an intuitive semantics called the “meaning explanations." Crucially, when meaning explanations are taken as definitive for type theory, the core notion is no longer “proof” but “verification”. We’ll explore how type theories of this sort arise naturally as enrichments of logical theories with further judgements, and contrast this with modern proof-theoretic type theories which interpret the judgements and proofs of logics, not their propositions and verifications. Expect the following questions to be answered: What is the difference between a judgement and a proposition? What is a meaning explanation? What is the difference between a proof and a verification? The so-called semantical approach to type theory is, in the speaker's view, more immediately philosophically acceptable than the modern syntactic one, and also provides a basis for a future where partiality and other effects may be treated naturally through refinement and behavioral typing, rather than by means of term-level monads and similar kludges.

None HTTP through Functional Programming Andrew Cherry

HTTP is a fascinating standard — one of those that we all use every day. But there are many different ways of reasoning about what HTTP "should" mean. We'll look at some of the approaches taken to model the HTTP layer, particularly in functional programming. Graphs, proofs, type systems — they're all fair game!

ooErlang ooErlang: A Programmer-Friendly Approach to OOP in Erlang Emiliano Firmino

Object-oriented Programming (OOP) dominates the industry. Most developers have experience with OO, but are new to functional programming. To help bring them to functional programming, we developed ooErlang, an extension of Erlang that fully supports OO with simpler syntax than previous approaches. This talk presents how we have implemented ooErlang and how to start using it.

ClojureScript A Bird's Eye View of ClojureScript Chandu Tennety

Birds travel thousands of miles each year to migrate, flying for hours on very little food and rest. By comparison, migrating databases seems like a paltry feat. Birdwave is a way to visualize the amazing phenomenon of bird migration. Using ClojureScript and Om allowed the app to be written in a declarative, concise manner, taking full advantage of JavaScript interoperability, as well as Clojure’s awesome built-in features such as persistent data structures and the async module. Also, prepare to be dazzled by the data-viz powerhouse that is d3. No birds were harmed in the creation of Birdwave. Or this talk.

Scala Scalaz-Streams: A Functional Approach to Compositional, Streaming I/O Derek Chen-Becker

[serious announcer voice] In a world gone mad with data, one library stands alone in the fight against sloppy, unsafe processing. [/serious announcer voice] The scalaz-stream library brings type safety, flexibile composition and powerful abstractions to the world of streaming data processing. This talk will start out with the basic building blocks and move on to advanced techniques, covering the good, bad, and the ugly along the way.

Scala Reactive Programming with Algebra André van Delft, Anatoliy Kmetyuk

R&D on reactive programming is growing and this has delivered many language constructs, libraries and tools. Scala programmers can use threads, timers, actors, futures, promises, observables, the async construct, and others. Still it seems to us that the state of the art is not mature: reactive programming is relatively hard, and confidence in correct operation depends mainly on extensive testing. Better support for reasoning about correctness would be useful to address timing dependent issues. The Algebra of Communicating Processes (ACP) has a potential to improve this: it lets one concisely specify event handling and concurrency, and it facilitates reasoning about parallel systems. There is an ACP-based extension to Scala named SubScript. We show how it helps describing the internal behavior of Akka actors, and how it combines with futures. For more information see

Scala Cats — A Fresh Look at Functional Programming in Scala (Mike) "Stew" O'Connor

Cats is a library that aims to fill in the gaps in the Scala standard library that we think are necessary to do pure functional programming in Scala, in the same way that Scalaz attempts to fill the same role. This project intends not only to create a functional library, but it intends to create a community welcoming to all. Having the opportunity to start on a library like this from scratch gives us many delicious opportunities to rethink some past decisions, and this is allowing us to innovate in unexpected ways.

Haskell Programming and Math Harold Carr

Design patterns are a useful way to organize software. Unfortunately, "gang-of-four"-like patterns are not composable, due to side-effects. In a pure (i.e., no side-effects) language, functions can be composed. That makes it possible to leverage patterns from mathematics. This talk shows an algebra of function composition, identity functions, isomorphisms, (co)products (gluing functions that do not compose) and functors. It shows how this algebra relates to real-world programming. The goal of this talk is to provide an initial intuition of how to apply patterns from math to programming and to motivate you to continue studying on your own (perhaps by looking at the "uber" patterns of Category Theory). Note: knowing these patterns is NOT necessary for getting work done in a functional language, but this talk should give a glimpse of why they may be useful. The talk illustrates ideas using Haskell. It is aimed at FP beginners.

None Introduction to Intuitionistic Type Theory Vlad Patryshev

Traditionally, in Computer Science, sets are assumed to be the basis of a type theory, together with Boolean logic. In this version of type theory, we do not need sets or Boolean logic; intuitionism is enough ("no principle of excluded middle required"). The underlying math is Topos Theory, but you are not required to be even aware of its existence. The theory is described using diagrams, not the traditional (and tricky) deduction rules. The resulting theory turns out to have dependent types. A simple "real-life" example or two will illustrate all this.

None The Case for the Cutting-Edge Matt Farmer

This is the story of a road less traveled. In this talk we're going to take a look at the impact of choosing less common technologies like Scala and Clojure at an organizational level at Elemica. That will include some things that worked well for us, some things that didn't work so well, a myth or two we were able to dispell along the way, and land with why the process of figuring all of that out is a worthwhile endeavor.

Haskell Give me Freedom or Forgeddaboutit: What Does "Free" Really Mean? Joseph Tel Abrahamson

The Haskell community is often abuzz about free monads and if you stick around for long enough you'll also see notions of free monoids, free functors, yoneda/coyoneda, free seminearrings, etc. Clearly "freedom" is a larger concept than just Free f a ~ f (Free f) + a. This talk explores briefly the origins of "freedom" in Category Theory, explains what it means for you to have a "free X" for any thing X, and talks a little bit about some useful free structures which exist in Haskell.

Haskell Finally Tagless DSLs and MTL Joseph Tel Abrahamson

Finally Tagless DSLs are a DSL embedding technique pioneered by Oleg Kiselyov, Jaques Carrette, and Chung-Chieh Shan that is in some sense "dual" to the notions of free-monad interpreters. MTL is a very popular monad library in Haskell which just so happens to be, unbeknownst to most, a Finally Tagless DSL itself. This talk explores what the Finally Tagless DSL style offers and shows you can use that concept to extend your effect-typing vocabulary in MTL.

Clojure Clojure vs Design Patterns Ron Toland

In this talk, I'll look at how design patterns from OOP translate to Clojure: some are unnecessary, some are embedded in the language, and others are easier to build.

Scala Simple Collection to Distributed Processing in Functional Way Rahul Kavale

In this presentation, I'll be talking about the way functional programming ideas affect and fit into the distributed computing world. With the introduction of Apache Spark, these ideas have been implemented quiet successfully. In this talk, I will be implementing (live coding) a distributed collection abstraction using basic principles of Functional programming. I will start with computation on simple in memory collection, and evolve it into a fully distributed collection having properties like fault tolerance, etc.

Scala Computation Expressions in Scala Jean-Rémi Desjardins

Computation Expressions are a generalization of do-notation and Idiom Brackets. They provide a single notation that uses the least powerful abstraction in order to translate sugared code into de-sugared code in the most flexible way possible. I will present a project I have been working on to implement computation expressions in Scala. In particular, I will show how this notation helps write asynchronous code with very little cognitive overhead.

Various Parametricity: The Essence of Information Hiding Kris Nuttycombe

This introductory talk is designed to help students new to functional programming understand how type parameters enable us to more easily reason about the behavior of functions and create APIs that enforce their invariants with type-level constraints. We will cover the principles of universal and existential quantification, review examples of reasoning about behavior from function types, and discuss implications for compositionality in API design. While most examples will be in Haskell, we will discuss how the principles generalize even to code written in unityped languages.

Scala Monads - Asking the Right Question Pawel Szulc

When entering the world of functional programming, one is quickly introduced with a concept of a Monad. Concept that is for some reason really hard to grasp and comprehend. When querying the Internet for "What is a Monad?" you will most likely learn that "you do not need to know the category theory to understand monads" and that "you are not asking the right question". The first thing that came to my mind, when I was struggling with this dilemma, was "Well, what is the right question then?".

This talk is all about looking for that right question and answering it. After this talk I hope you will find yourself knowing and understanding the concept, being able to apply it in a daily programming routine.

Rust In Rust We Trust Alex Burkhart

Rust aims to build a solid foundation for building safe software systems faster. We can ensure fewer mistakes enter our code base with immutability by default, no concept of null, and proven memory safety. Rust's state of the art compiler helps developers catch errors as early as possible without paying a penalty at runtime. Developers can write high level code in a modern language without sacrificing expressiveness, development time, or execution speed.

We will explore how Rust's concept of Ownership is the key to providing compile-time safety. These guarantees apply even in the face of concurrency, allowing you to easily write multi-threaded programs correctly the first time.

Rust 1.0 was released May 15th. Start building better software today.


Boulder is a beautiful mountain town nestled in the heart of Colorado, boasting a thriving tech scene and a burgeoning community of functional programmers.

Boulder has gathered numerous top rankings in recent years, including:

  • The 10 Happiest Cities – # 1 –
  • Top Brainiest Cities – No. 1 –
  • Ten Best Cities for the Next Decade – 4th – Kiplinger's Personal Finance magazine
  • Gallup-Healthways Well-Being Index – No. 1 – USA Today
  • Best Cities to Raise an Outdoor Kid – No. 1 – Backpacker Magazine
  • America's Top 25 Towns to Live Well – No. 1 –
  • Top 10 Healthiest Cities to Live and Retire – No. 6 – AARP magazine
  • Top 10 Cities for Artists – No. 8 – Business Week
  • Lesser-Known LGBT Family-Friendly Cities – No. 1 –
  • America's Foodiest Town – No. 1 – Bon Appetit magazine

The city is very compact, making it easy to get around on foot or bicycle, and boasts an incredible variety of great dining options, local musicians, street performers, and live shows.

Boulder has hundreds of miles of maintained hiking trails, is 30 minutes away from the nearest ski resort, and has one of the most physically active communities in America.

Getting Around

Boulder has an excellent public transportation system, which is integrated into Google Maps. Google Maps can give you directions around Boulder using the transit system.

Boulder is also very walkable. If you are staying close to downtown and don't mind walking, you probably won't need any other form of transportation.

Finally, Boulder is bike-friendly, and you can rent bikes from stations around town as part of the Boulder B cycle program.


Boulder is served by the Denver International Airport (symbol: DEN).

Low-cost national carriers into Denver include Frontier Airlines and Southwest. These carriers fly from most major cities in the United States, and you can often find a round-trip fare for around $200.

British Airways has direct, non-stop flights from London Heathrow to Denver.

The best way of getting from the airport to Boulder is the RTD Boulder AB Bus Route. The bus takes about an hour and drops you off at the Boulder Transit Station, which is located in the heart of downtown Boulder, and a short walk away from our recommended hotels.

Unless you will be staying outside of Boulder, you probably do not need to rent a car. Boulder is extremely walkable and bikable and also has excellent public transit options.


If you are coming from out of town, we recommend staying in downtown Boulder or around the University of Colorado Boulder, for ease of access to the conference events.

We have a small number of reserved rooms at the following two hotels:

  • Boulder Hyatt $179 (King) and $199 (Double Queen) per night plus tax. This includes Kitchen Skillet Breakfast, Wi-Fi access, indoor pool / whirlpool, and 24/7 StayFit gym.
  • Boulder Marriott for $179 per night.
  • The Boulder Inn for $174 per night. Call 800-233-8469 and reference code "LambdaConf 2015".

Other options include Hotel Boulderado, St Julien, Quality Inn & Suites, Millennium Harvest House, and Boulder University Inn, all within walking distance to downtown Boulder.

You may also find good deals on Airbnb Boulder, especially if you are considering rooming with fellow conference attendees.


University of Colorado

The venue for all events is the Wolf Law Building at University of Colorado Boulder. Friday parking on campus will not be free. All-day parking permits for Friday are available here, and if you'd like to pay day of, you can use Parkmobile. For other options, including metered and hourly parking, please see CU's Parking & Transportation Services website. Street parking is available east of Broadway, but please respect local parking signs.

Note: Friday night, the drink social will occur at various places around town. See your drink tickets for details.



Andi McClure

Andi McClure has been making independent games and game frameworks since 2008. Her work explores the intersection of games, art software, and computation; "BECOME A GREAT ARTIST IN JUST 10 SECONDS", her glitch-art collaboration with Michael Brough, was an official selection at the Indiecade festival, and was a finalist at the 2015 Independent Game Festival awards. Oh, and she used to write garbage collectors, but that was a really long time ago.


Joseph Tel Abrahamson

Joseph has a background in biomedical engineering, statistics, and signal processing. He is a self taught functional programmer and entrepreneur currently working on a small company in the space of clinical research operations. His programming interests revolve around the divide between building great products and the mathematical structure that gives them form.


Marconi Lanna

Marconi has been writing software for fun and profit since last century, when the Internet was still black & white and silent. He loves computers, Internet, curly braces, angle brackets, Scala, and working with great people. Marconi is Senior Software Innovator at Originate and spends most of his free time trying to get his little daughter out of trouble. He has been programming in Scala since 2010.


Aysylu Greenberg

Aysylu Greenberg works at Google on a distributed build system. In her spare time, she works on open source projects in Clojure, ponders the design of systems that deal with inaccuracies, paints and sculpts.


Zeeshan Lakhani

Zeeshan became a programmer by way of film and music recording/technology. Moving from science center to startup to labs to working on distributed systems at Basho, he has accrued tons of necessary and needless information, and is a polyglot who will dive into anything related to programming languages, particularly functional ones, machine learning, and math. Additionally, he is one of the lead organizers and founders of Papers We Love!


Vlad Patryshev

Mathematician by education, programmer by profession, Vlad Patryshev currently calls the Bay Area his home. Vlad has worked at Borland, Google, and a bunch of startups. A fan of functional programming and strong types, Vlad also organizes Scala Bay and Bay Area Categories & Types, and teaches logic and formal methods at Santa Clara University.


Sergii Dymchenko

Sergii Dymchenko is a generalist software developer. He uses mostly Python to do the job, but he also uses Lisp, C++, Prolog, JavaScript, SQL, R, GAP, PHP, and other languages. Because of his interest in programming languages (especially non-mainstream and obscure), Sergii founded Progopedia, the free encyclopedia of programming languages.


Alejandro Serrano Mena

Alejandro Serrano Mena is working towards his PhD thesis in the field of type errors for domain-specific languages at Utrecht University. Passionate about functional programming, Alejandro has been using Haskell and Scala in hobby and professional projects for more than five years. He recently published the introductory book Beginning Haskell. In 2011 and 2014, he worked on improving support for Haskell in the Eclipse IDE and the Emacs text editor, including interactive support for hole-driven development, under the umbrella of the Google Summer of Code.


Jared Roesch

Jared Roesch is currently a graduate student at UCSB studying Programming Languages, specifically type systems, guided test program generation, and whacky computer architectures. Jared is interested in ways to make programs faster, safer, and easier to write. His most recent work has been on focused on Rust, specifically the type checker, a few libraries, and experiments in type level programming.


Doug McIlroy

Educated at Cornell and MIT, Doug McIlroy became an adjunct professor in computer science at Dartmouth upon retiring from a long career at Bell Labs, where he headed the department in which Unix was born. For that system, he fostered the concept of pipes and created many standard utilities. He is a member of the National Academy of Engineering and a recipient of Usenix awards for software tools and lifetime achievement.


Ranjit Jhala

Ranjit Jhala is a Professor of Computer Science and Engineering at the University of California, San Diego. He is interested in building algorithms and tools that help engineer reliable computer systems. His work draws from and contributes to the areas of Model Checking, Program Analysis, and Automated Deduction, and Type Systems. He has helped create several influential systems including the BLAST software model checker, RELAY race detector, MACE/MC distributed language and model checker, and is now working to sneak formal specification and verification into daily programming, under the disguise of types.


Paul Phillips

Paul Phillips is co-founder of Typesafe and the all-time most prolific Scala committer. No longer affiliated with either, he now volunteers as Scala's conscience.


Adelbert Chang

Adelbert Chang is currently a Software Engineer on the Search and Analytics team at Box. He is a recent graduate from the University of California, Santa Barbara where he studied Computer Science and researched graph querying and modeling. His recent interests lie in building functional tools, systems, and infrastructure.


Adam Pingel

Adam Pingel is a Software Engineering Manager at VigLink in San Francisco. He is a veteran of the dot-com bubble who fled to academia in 2002 when it appeared that Python and Ruby were only viable successors to Perl and Java. In 2009 he returned to industry full-time. Nowadays he writes a lot of Scala. He holds a BS in CS from Stanford and an MS in CS from UCLA.


Justin Campbell

Justin is an experienced developer with a passion for automation and software craftsmanship. He'll tell you he's from Philly, but ew he lives over the river in New Jersey.


Gershom Bazerman

Gershom is a software developer in New York City. He is an organizer of the NY Haskell Users Group and the NY Homotopy Type Theory Reading group, and a member of the committee. He has written a number of widely used Haskell packages, most notably the JMacro library for programmatic generation of JavaScript. He has a particular interest in popularizing results of research related to and deriving from the mathematical foundations of computer science. He occasionally contributes blog articles at the Comonad Reader.


Riccardo Terrell

Riccardo Terrell, is a Software Architect at Microsoft who is passionate about functional programming. He is active in the F# community and started the DC F# user’s group. Riccardo is a believer in polyglot programming as a mechanism in finding the right tool for the job. He likes to describe himself as a functional guy living in an imperative world.


Alex Gremm

Alex Gremm is a Software Developer with a passion for high-performance and distributed systems. He dreams of a world where writing software is fun and detached from the underlying hardware architecture. So far, Haskell is his language of choice for doing so.


Richard Eisenberg

Richard is a PhD student studying dependent type systems at the University of Pennsylvania. The particular aspect of dependent types under consideration is how, exactly, to incoporate dependent types into Haskell and GHC, without breaking existing code. In a former life, he was a high school teacher of computer science in Massachusetts and London. He currently resides outside Philly with his wife and daughter, and is very much looking forward to hiking in the flatirons while in Boulder.


Paige Bailey

Geophysicist with computer science habits. Passionate about public transportation, sustainable energy, scientific computation, STEM education reform, adventures — and how functional languages can enable all of the above. Paige Bailey is an Earth Sciences graduate student at Rice University; founder of PyLadies-HTX; and is employed full-time by Chevron in upstream technical computing.


Rob Norris

By day Rob writes software for big telescopes, and by night he hacks on open-source FP libraries, mostly in Scala. He is a regular irritant on IRC and Twitter where he goes by the handle tpolecat. Rob lives in Portland with his wife, daughter, and cat, all of whom are very good sports.


John A. De Goes

A mathematician by training but a software engineer by vocation, John A. De Goes has been professionally writing software for more than 20 years. John has contributed to dozens of open source projects written in functional programming languages. In addition to speaking at Strata, OSCON, BigData TechCon, NEScala, and many other conferences, John also published a variety of books on programming. Currently, John consults at De Goes Consulting, and serves as CTO at SlamData Inc, an open source company strongly committed to solving hard problems in analytics using pure functional programming.


Jon Sterling

Jon Sterling is a reluctant Haskell programmer and former student of ancient languages; his primary interests are intuitionism, type theory and assyriology. He is also a co-host of The Type Theory Podcast, and occasionally writes at


Phil Freeman

Phil Freeman is based in Los Angeles, and works on medical imaging software written in Scala, Haskell and TypeScript. He also maintains the PureScript compiler and related projects in his spare time. He is motivated by the problem of software correctness in real-world code, and applying the techniques of functional programming and language design to solve that problem.


Colt Frederickson

Colt Frederickson gets to work on hard problems involving big data at Oracle where he writes almost exclusively Scala. He uses Functional Programming techniques via Scalaz to make Scala a more principled language. He lives in Bozeman, MT where he tries his best to take advantage of the outdoors. Snowboarding, biking and backpacking are at the top of the list.


Chris Allen

Chris is a long-time polyglot programmer, with a special interest in Lisp and FP. He currently works in and maintains several projects in Haskell, such as Bloodhound and Blacktip. Discovering Haskell reignited his love of learning and made him want to teach what he learned. He created the Learn Haskell guide on Github, started the #haskell-beginners channel on IRC, and spends time coaching other Haskellers who want to teach. The insight he's gained from these experiences have led him to rethink Haskell pedagogy. He's currently working on producing a book for learning Haskell.

picture of nick heiner

Nick Heiner

Nick is a web developer at Opower, where he uses node.js and Angular to help people better understand (and thereby reduce) their energy usage. He lives near Washington DC and enjoys speaking at local meetups. Prior to Opower, he interned at Google and Microsoft. Nick has contributed to open source projects such as Bower, Foundation, and Chai, and he writes on Medium.

Despite being primarily a JavaScript developer, Nick maintains a deep affection for F#.


Ben Burdette

Ben Burdette is a long time C++ programmer transitioning into functional software development.


Brian McKenna

One of the many Australian functional programmers. Working as one of the few professional PureScript engineers. Trying to improve front-end development by applying more functional programming and functional programming by applying more types. Brian says silly things on Twitter as @puffnfresh.


Andrew Cherry

Andrew Cherry is a consultant and software developer who specializes in scalable, distributed systems using functional approaches. Even after 15 years he'd happily spend all day every day experimenting with new ways of coding and new ways of building things, but unfortunately sometimes work prevents this. He's particularly interested in type systems and type theory. He's never been to Colorado before, and wonders what the air's like up there.


Emiliano Firmino

Software developer at INDT and Eletrical Engineering Master's Student at Federal University of Pernambuco. I'm enthusiast of software development, functional programming languages and operational systems. I extended Erlang AST to support ooErlang extension and current mantainer of ooErlang.


Chandu Tennety

Chandu stumbled out of the jungles of manufacturing and ERP consulting, and landed in the zen garden of software development. He has been contemplating the nature of the Object Model ever since. When not developing, Chandu enjoys family time, drawing, hiking, drinking tea, birdwatching and solving cryptic crosswords.


David Greenberg

David Greenberg loves learning. He currently works at Two Sigma, where he leads several efforts to build reliable, distributed cluster computing environments. He also enjoys writing Clojure.


Joe Nash

Joe is a Developer Advocate for Braintree, a PayPal Company. Having learnt the dark arts of FP at the University of Nottingham, Joe is undergoing a PhD in parallel and heterogeneous systems at the University of St Andrews. He believes in the educational benefits of hackathons and hack culture, and supports student hackathons as part of the EU team at Major League Hacking.


Vincent Marquez

Vincent Marquez is a consulting software engineer in Orange County. Current clients include 10thDegree, a digital advertising agency, and JazelAuto, an automotive marketing platform, where he uses Scala and .NET to implement highly concurrent systems. He has worked in the industry for over ten years developing products ranging from VoIP servers to E-commerce services. He is an enthusiastic fan and evangelist of Open Source and an active contributor to Scalaz.


Derek Chen-Becker

Derek Chen-Becker is a software engineer for SimpleEnergy, a Boulder-based B-Corp focused on motivating people to save energy. He currently works on large-scale data ingest and analysis using Scala, and has previously worked as a Java developer, Network Engineer and Unix Sysadmin. Derek loves to learn about all things FP and is starting to work on more projects in Haskell. Although his colleagues wince when he says it, his goal is to bring pragmatic FP approaches to the masses.


André van Delft

André van Delft is an independent computer science researcher in the Netherlands. He has studied Mathematics and Business Administration. He loves math and applies it in programming language extensions.


Anatoliy Kmetyuk

Anatoliy Kmetyuk studies law in Odessa National Academy of Law, Ukraine. Since 2012 he has been self-educating in the domain of software engineering, computer science and mathematics.


Brian L. Troutwine

Brian L. Troutwine is a software engineer with a focus on fault tolerance and real-time systems. His professional projects tend to be done in Erlang. Presently he's employeed with AdRoll as a senior engineer on the real-time bidding project.


Priyatam Mudivarti

Priyatam is a writer and polyglot engineer specializing in apis and user-interface design. After building software for twelve years in all layers of the stack in enterprises and creative agencies, he found his passion at the intersection of literature and lisp. He’s the founder and principal at Facjure, a tiny studio, and is currently working on a novel.


Richard Feldman

Richard is a functional programmer who specializes in pushing the limits of browser-based UIs. He's built a framework that performantly renders hundreds of thousands of shapes in HTML5 Canvas, a JavaScript immutables library that seamlessly interoperates with normal JS collections, a long-form writing web app that functions like a desktop app in the absence of an Internet connection, and much more in between.


Mike (Stew) O'Connor

After spending a decade Proxying AbstractBeanInstaces from FactoryBuilderImpls in Java land, Stew found himself on a project using scala, and hasn't looked back since. Stew is currently a software architect for Verizon where he spends a lot of energy evangelizing about the power of a more pure approach to functional programming. In his spare time he's writing documentation for the newly formed Cats project.


Steven Proctor

Proctor is the founder and organizer of the Dallas/Fort Worth area’s Erlang User Group; creator, manager, and curator of; and has a blog post series Erlang Thursday, which has been picked up and translated to Lisp Flavored Erlang by Erlang co-creator Robert Virding. Proctor is also the host of the podcast Functional Geekery, a podcast covering various topics and languages centering around functional programming.


Sharon Steed

Sharon is the director of business development and marketing for speech IRL, a communications firm delivering speech therapy and corporate communications training. She is a life-long stutterer that speaks about fear and vulnerability at the intersection of marketing, communication, business and tech. She has spoken to universities about stuttering, at Ignite Chicago about patience, Madison+ Ruby about branding and to a host of other audiences. She lives in Pittsburgh.


Harold Carr

Harold Carr is architect of InfiniBand usage in WebLogic Server at Oracle. He also designed and implemented the pluggable transports, the asynchronous client and service APIs, and streaming I/O used in Oracle's SOAP stack. At Sun Microsystems he worked on RMI-IIOP load-balancing and fail-over, the architecture of Sun's CORBA ORB and JAX-WS 2.0, and the scalable NIO communications architecture (aka Grizzly). He worked on distributed Lisp and C++ with Hewlett-Packard Research Laboratories and Schlumberger Research Laboratories, was Chief Architect of Lisp technology at Autodesk, and did logic simulation for Cirrus Logic. He holds a Ph.D., in Computer Science from the University of Utah.


Matt Farmer

Matt is a Software Developer for Elemica, working with the Engineering Department on building Elemica's next-generation supply chain solutions. His weapons of choice include Scala and Clojure in addition to the usual suspects of frontend web languages. He contributes semi-regularly to the Lift Framework and is organizer of the Georgia Open Data Project. During Spring and Summer it's usually a pretty good bet that he's going to be on his bike zipping up and down the Atlanta BeltLine.


Adam Foltzer

Adam was lucky enough to begin programming in Scheme when he was quite young, and has since then had a passion for functional and denotational programming. While getting a B.S. and M.S. in Computer Science from Indiana University, he began using Haskell while studying the theory, design, and implementation of programming languages; parallel and concurrent programming; and quantum and reversible computing. Prior to studying Computer Science, he studied Russian language and literature, archaeology, and how to fly small aircraft.


Daniel Spiewak

Daniel Spiewak is a software developer based out of Boulder, CO. Over the years, he has worked with Java, Scala, Ruby, C/C++, ML, Clojure and several experimental languages. He currently spends most of his free time researching parser theory and methodologies, particularly areas where the field intersects with functional language design, domain-specific languages and type theory.


Mark Farrell

Mark Farrell is currently a second-year student in Mathematics at the University of Waterloo, located in Waterloo, Ontario, Canada. He hopes to specialize in a close cousin of Computer Science known as Combinatorics & Optimization. Recently, he has completed software development internships at Dalhousie University and Defence Research & Development Canada, both also located in Canada. During his internships, he was able hone his interest in functional programming with programming languages like Scala, Clojure and Scheme/Racket. He has also made a couple of small contributions to projects like Scalaz & Idris - and hopes to continue learning more about functional programming & PL theory in the future!


Ron Toland

Ron Toland started out as a front-end web developer in 2007, and has been steadily moving down the stack ever since. Two years ago he burrowed into the role of building back-end services in Clojure, and refuses to budge from there.


Joseph Abrahamson

Joseph has a background in biomedical engineering, statistics, and signal processing. He is a self taught functional programmer and entrepreneur currently working on a small company in the space of clinical research operations. His programming interests revolve around the divide between building great products and the mathematical structure that gives them form.


Rahul Kavale

Rahul works as an Application Developer at ThoughtWorks. He is interested in multiple technologies ranging from building web applications to solving big data problems. He has worked in multiple languages including Scala, Ruby, Java and has worked on Apache Spark, Hadoop, Hive. He enjoys writing Scala.


Brendan McAdams

Brendan is a Senior Consultant at BoldRadius, where he works directly with clients to help them find success through consulting and training on the Typesafe Reactive Platform. With over 15 years of software development experience, Brendan boasts an impressive resume that has seen him work at Netflix, Typesafe, and MongoDB.

Brendan is a renowned speaker and luminary in the Scala community, and is a regular presenter at industry leading conferences such as Scala Days and Scala eXchange. His deep technical knowledge coupled with his outgoing and approachable personality not only make him a great speaker, but also a phenomenal trainer on the Typesafe Reactive Platform.


Kris Nuttycombe

Kris is an independent software consultant and entrepreneur based in Boulder, CO. His first introduction to functional programming was in 2008 when, after a decade working in Perl, C, Java, and Ruby he discovered Scala and realized that there was a lot he didn't know about programming. Since then, he's become a devotee of Haskell, and each day comes to realize that he knows even less than he previously thought. His specialty is multi-KLOC refactorings that make his coworkers wince; his current project involves refactoring the mechanisms of global capitalism.


Pawel Szulc

Software engineer, programmer, developer. Experienced with Java ecosystem. Currently having tons of fun working with Scala, Akka and Apache Spark. Humble apprentice of Functional Programming. Runs a blog


Jean-Rémi Desjardins

Jean-Rémi has always had a passion for programming languages and how to make them better. This has lead him to study many different languages and paradigms. Scala was his gateway drug into the world of advanced programming languages and although he loves to tinker and read about new languages, he still does the vast majority of his development in Scala. His recent area of focus has been type-level programming and meta-programming.


Deian Stefan

Deian Stefan is a PhD student in Computer Science at Stanford and co-founder and CTO of GitStar, a company that provides security-as-a-service to web developers. He is interested in systems, programming languages, and security. Deian's recent work focuses on web application security; he built practical systems—namely Hails, LIO, and COWL —with formal underpinnings that enable average developers to build secure web applications.


Alex Burkhart

Alex Burkhart is a software developer at Mutually Human. He loves creating software, but hates being woken up by production errors. Alex loves to pair, mentor new developers, and share knowledge with the entire community. Alex founded the Columbus Rust Society in October 2014. When he isn't programming, he is often found playing board games or rock climbing.


Be sure to follow LambdaConf on Twitter for up-to-the-minute news on changes to conference schedule or venues.

Below, you can chat about the conference, discuss sharing accommodations or transportations (road trips!), and coordinate social activities with fellow attendees.

Code of Conduct

LambdaConf's code of conduct is simple: be a decent human being.

Embrace and celebrate diversity, treat everyone with respect and dignity, and in the words you speak and the actions you take, show genuine care and concern for helping others achieve their goals.

We have a zero tolerance policy towards written or spoken words, behaviors, artifacts, and media that make minority groups feel bullied, harassed, intimidated, stalked, stereotyped, or belittled. These groups include women, people of color, disabled individuals, lesbians, gays, bisexuals, transsexuals, asexuals, intersex people, transgender people, and gender-variant people.

Violations of this code of conduct should be reported immediately to conference volunteers or staff. All staff and volunteers will be wearing clearly marked Team LambdaConf apparel.

Attendees acting like jerks will be thrown out by this guy. Don't say we didn't warn you.




John A De Goes

Event Organizer

John is the main organizer for LambdaConf, and an avid (wanna-be) functional programmer. When not starting analytics companies or hacking on open source, John spends his time in front of a mirror practicing his best Vulcan impression (we're just kidding, but he's still a complete dork!).


Courtney De Goes

Event Logistics and Coordination

Courtney is the amazing event coordinator for LambdaConf, responsible for ensuring you come back for more. In her free time, 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 De Goes

Brand, Web Designer and 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 and kittens). Rumor has it, he can fix anything with duct tape.


Sophia De Goes

MD and Assistant Coordinator

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 his all-around geeky entrepreneurial self.



Paige Bailey



Matthew Chan



Jimmy Torre



Temi Toriola



David Kua