EMPEX is a sophisticated conference series for functional programming languages and ecosystems held in New York City. We present a single track of technical talks in a jazz club. Our goal is to bring a sense of aesthetic and fun to the growing functional community. We'd love for you to join us!


EMPEX will be held at Subculture, an intimate jazz club in Soho.

45 Bleecker St, New York City, 10012
Find it on Google Maps


Doors open / Registration
Breakfast & Chat
Opening Remarks
Dave Thomas: Keynote
With Brian Mitchell
Zack Kayser: Demystifying Purely Functional Data Structures in Elixir
Desmond Bowe: Erlang Ecosystem Foundation Presentation
Vaibhav Sagar: Functional DevOps in a Dysfunctional World
Eric Meadows-Jönsson: Introducing Mint, a process-less HTTP client
Andrew Forward: LiveView; Rich Client Side Experience Delivered From the Server
Meryl Dakin: Process Potential: Multitasking and fault tolerance in Elixir
Jon Carstens: Dadgineering with Elixir+Nerves
Billy Ceskavich: Is Elixir Just Lisp? Demystifying Metaprogramming in Elixir and Beyond
After Party!

At Swift Hibernian Lounge


We're excited and proud to announce our keynote speakers for the fourth annual EMPEX!

Thomas dave

Dave Thomas


Dave Thomas has written code just about every day in the last 45 years. One day he’ll get it right.

He’s an author: The Pragmatic Programmer, The Manifesto for Agile Software Development, Programming Ruby, Agile Web Development with Rails, and recently Programming Elixir. He speaks at conferences around the world, and runs training for folks who want to enjoy themselves while learning (kind of like a Comedy Defensive Driving class).

But mostly he writes code; sometimes to solve problems, sometimes to understand problems, and often to create them.

He has strong and controversial views on how Elixir should be written; prepare to be both entertained and annoyed.


We're proud to announce the following presenters for EMPEX!
Andrew Forward headshot

Andrew Forward

LiveView: Rich Client Side Experience Delivered From the Server

Let’s welcome LiveView to the Elixir Phoenix ecosystem. Wanted: rich user experience, JavaScript frameworks need not apply.

Despite being very (very) new come learn more about some common user interface features that can be solved with LiveView, and some lessons learned along the way to refactoring away from custom JavaScript and towards LiveView controllers.

About Andrew: Andrew Forward is happiest during biking season. Otherwise reserved, he has a passion for software engineering, finance and fitness; often intermixing all three. Andrew works remotely as a developer for CrossFit HQ, but also dabbles as a part-time professor at the University of Ottawa. Andrew came to Elixir for the syntax, but stayed for the OTP.

Billy Ceskavich headshot

Billy Ceskavich

Is Elixir Just Lisp? Demystifying Metaprogramming in Elixir and Beyond

Metaprogramming is a powerful tool that many Elixir developers use every day. Via macros, we can write concise, reusable code, and even extend the language itself. But, metaprogramming in Elixir can be hard to grok, especially for newcomers. So in this talk, we’re going to review the inner workings of Elixir’s metaprogramming environment. We’ll start with a quick syntax review, and discuss in plain terms what the core components do for you. Then, we’ll talk about the essence of macros: modifying Elixir’s Abstract Syntax Tree to reshape your code at compile time. And finally, we’ll compare Elixir’s macros to metaprogramming approaches taken in other languages. Whether you’re new to Elixir or a seasoned developer, you should leave this talk with a clearer understanding of how this powerful set of Elixir abstractions works and how you can use it all confidently in your next project.

About Billy: Billy is a software engineer based in Brooklyn, NY. He works at Frame.io, where he wrangles Elixir and JavaScript to help build their developer platform. He wrote his first Elixir program in 2016 and started writing Elixir full-time in November 2018. When he's not writing code, he's probably baking or hanging out with his cat.

Brian Mitchell headshot

Brian Mitchell

In Conversation With Dave Thomas

Brian will engage with Dave Thomas on topics posed by Dave.

About Brian: Brian Mitchell has worked with Erlang for many years and enjoys what Elixir brings to the ecosystem. He has worked in a wide variety of domains that range from embedded systems to clustered database systems. He enjoys teaching others about various interesting ideas he has encountered during his programming career. When not coding, you might catch him playing the game of Go.

Eric Meadows-Jonsson headshot

Eric Meadows-Jönsson

Introducing Mint, a process-less HTTP client

In this talk we will present Mint, a new HTTP client for Elixir supporting HTTP/1 and HTTP/2. Mint has a process-less architecture using pure data structures, we will show why this architecture gives the developer more flexibility in how they can use the library but also the possible downsides of this approach. We will look at different use cases for Mint and finally go into some of the details of how to implement a HTTP library and how to build libraries using pure data structures.

About Eric: Eric Meadows-Jönsson is a member of the Elixir team and an active member of the Elixir community being the creator of many libraries, including Ecto and the Hex package manager. Eric is a co-author of the book "Programming Ecto" published by Pragmatic Bookshelf.

Jon Carstens headshot

Jon Carstens

Dadgineering with Elixir+Nerves

Are you a parent of children, pets, or just really immature roommates? Do you wish you could use Elixir to help solve household issues and annoyances? Do you frequently over-engineer side projects? Then you might be a dadgineer (or momgineer).

This talk is compilation of fun projects using Elixir & Nerves to solve silly problems around my home. Projects such as a "Picture Board Turn Selector" to programmatically answer the age old question of "Whose turn is it!?", complete with LED light show. Or hardening the security of the toy storage room with electromagnetic latching and biometric unlocking procedure.

The projects are overly complex for the problems they are solving, but my hope is that it helps inspire others to break into the world of hardware. To provide yet another set of wild examples to show how fun and sometimes surprisingly easy it is to create your own customizations in the physical world.

About Jon: Happily married father of four young kids. Wannabe woodworker. Avid bike rider. Hardware fanatic. Lover of good BBQ, chocolate chip cookies, and swimming.

Meryl Dakin headshot

Meryl Dakin

Process Potential: Multitasking and fault tolerance in Elixir

Much of Elixir's hype has flowed around OTP: the concurrency and parallelism that promises multitasking at lightning speeds. However for newcomers to the language, the tools that enable this can be hard to visualize and intimidating to implement.

We'll start with processes and work up to GenServers. We'll take a look at a truly practical example of GenServers: an app that deploys hundreds of repos to Github Enterprise at once for students to use as lessons while maintaining global state. We'll delve into how it orchestrates the process with parallelism and fault tolerance. Both developers from OO backgrounds and those currently working in Elixir will gain a new comfort with the building blocks of multitasking and how to use them to their potential.

About Meryl: Meryl Dakin is a full stack web developer living in Brooklyn. She is a former instructor for the Flatiron School and volunteers with Code Nation. She has written several blog posts and made a small number of cartoons on various programming topics.

Vaibhav Sagar headshot

Vaibhav Sagar

Functional DevOps in a Dysfunctional World

What happens after you cut a release? Getting your finished software in the hands of your users can be quite an ordeal, especially if you use tools that make things harder than they need to be. It turns out that a functional approach has benefits even after the development team has written their last line of code.

I will motivate and demonstrate using the Nix suite of tools to package and deploy a web service, showing how this helps us reconcile the sometimes conflicting priorities of development and operations teams and allows us to respond nimbly to change as it occurs.

About Vaibhav: Vaibhav used to write web applications for a living. He still does, but he used to, too. When he's not doing that he yells about Nix on Twitter, reracks his bumper plates, and listens to a lot of really good disco.

Zack Kayser headshot

Zack Kayser

Demystifying Purely Functional Data Structures in Elixir

Reasoning about data structures and run times in functional languages like Elixir is a far cry from classic analysis of data structures in imperative languages. While working with immutable data structures helps us reason about the flow of state in our programs, it has implications on the data structures we choose to work with and the efficiency of operations on those data structures. We will start by briefly laying some groundwork for analyzing functional data structures and discuss some optimizations used to prevent unnecessary copying while maintaining immutability. We'll move on to take a look at some basic data structures implemented with examples in Elixir and then discuss their characteristics. Starting from naive implementations of these basic data structures and related operations on them, we will consider how to further optimize operations to draw out more efficient run times. The talk will wrap up with a discussion of how to build an intuition for creating more efficient data structures in Elixir.

About Zack: Zack is a software engineer at Gaslight in Cincinnati, Ohio, and has spent the last couple of years working on a wide variety of projects -- ranging from server-side applications, to iOS and web frontend enterprise applications, to one-day hackathon projects, all the way to game development for personal enjoyment (and pain :-D). Ever since being introduced to Elixir, Erlang, and OTP in 2016, he has been a huge proponent of functional programming and an evangelist for a movement towards more immutability and no shared state wherever possible. Prior to entering the software industry, he was a professional translator specializing in English to Japanese translation. Outside of work, Zack is an avid traveler and a long distance runner (but only when it is not winter in Ohio because cold is NOT cool).


Training courses will be held on May 17th, the day before the EMPEX conference. The location will be announced soon.

Get Your Training Tickets Now!

Frank Hunleth's Headshot

Frank Hunleth

Justin Schneck's Headshot

Justin Schneck

Device to the Cloud with Nerves and NervesHub

The Elixir language and Erlang runtime provide a uniquely robust and productive environment that runs well from embedded to server. This class extends on previous Nerves training to the cloud for device/server communications and device management with NervesHub. Attendees will assemble real devices and build out the software step-by-step for a simple multi-user game with the help of the authors of Nerves.

We’ll spend the first half of the day building the device and getting comfortable with developing and debugging on Nerves. If you’ve attended previous Nerves courses, this one will have greater emphasis on networking and device provisioning. The second half transitions to managing devices with NervesHub and developing a simple companion Phoenix application.

The workshop is appropriate for beginners and expert Elixir programmers alike since it focuses more on embedded development than pure coding. Since the Nerves development is rapidly improving, even veteran embedded Elixir programmers will learn new ways of making their development cycle better. Beginners to Elixir are highly encouraged to create a couple toy projects and learn about GenServers and OTP releases beforehand.

We will be providing Raspberry Pi’s and accessories to use during the class. It is unnecessary to buy hardware. We know from past classes that many people want to use hardware that they can take home. If you would like to do this, you can buy class materials beforehand:

Note that the Adafruit OLED Bonnet Pack requires you to solder a header onto the Raspberry Pi Zero. The Raspberry Pi Zero WH may be available with a pre-soldered header. Rest assured, if your hardware fails, we will provide a kit for the class.

Thinking In Types

In this one-day workshop, we'll explore the distinguishing features of Haskell's type system. Haskell has several varieties of types: sum types, product types, newtypes, as well as functions over types (aka "HKTs" or "type constructors"). There is no "any" type, no "null" value, no "subtype" relationships.

This workshop is intended for people who do not have much experience with the Haskell language, and the goal will be to give a practical understanding of some of Haskell's most important features and how to start thinking in types. Please come prepared to write code. It is recommended that you have GHC installed before the workshop begins.

About Julie

Julie Moronuki is an author of books about Haskell and co-founder of Type Classes, a Haskell education and consulting company. Before learning Haskell, Julie had been a linguist, librarian, and teacher. She lives in Montana.

Chris Bell headshot

Chris Bell

Crash Course in Elixir, for (Ruby, Java, JS, etc) Developers

Are you interested in Elixir, but you haven't yet learned the language?

Are you an imperative language programmer who's finding it tricky to get a handle on the functional approach?

Do you find yourself wishing that Elixir had a "for loop"?

We've all been there, and we've developed a one-day workshop to get you past the learning curve. Starting with the absolute fundamentals of Elixir's datatypes, we'll take you through every aspect of the language that tripped us up when we were learning.

By the end of the day, you will be able to confidently solve complex business problems faster and more reliably than you'd have ever believed possible. Learning to build solutions on top of immutable data structures requires a new way of thinking, and we've designed our workshop to get you thinking that way quickly.

We will cover:

  • All the built-in datatypes: numbers, binaries (strings), lists, maps, structures, tuples, and atoms.
  • Functions: anonymous functions, named functions, and higher order functions.
  • Pattern matching: This is a hugely powerful technique, and is probably the one thing most developers miss when they find themselves coding in another language after experiencing it in Elixir.
  • Elixir tooling: How our projects are organized, the build system, the dependency management system, the test framework, and the rich documentation system.
  • How to model problems using functional patterns instead of Object Oriented patterns.

Our aim is to provide a mentally challenging, but enormously rewarding day. Every segment will include hands-on exercises and challenges, and we will have two instructors helping you if you get stuck.

Who should come? The course is not for complete beginners. You should be comfortable programming in some language, but what language is unimportant. People whose proficiency lies outside the functional paradigm will probably get the most out of the course, but functional programmers who are new to Elixir will find the course to be a useful survey of the main features of the Elixir ecosystem.


If you're interested in sponsoring EMPEX NYC, please email info@empex.co.


David Antaramian Headshot

David Antaramian

Chris Bell Headshot

Chris Bell

Sophie DeBenedetto Headshot
Troy Denkinger Headshot

Troy Denkinger

Lisa Denkinger Headshot

Lisa Denkinger

Helen Hood Headshot

Helen Hood

Andy Mccown Headshot

Andy McCown

Lee Nussbaum Headshot

Lee Nussbaum

Cameron Price Headshot

Cameron Price