EMPEX, the Empire City Elixir Conference, is a sophisticated conference series for the Elixir programming language and ecosystem 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 Elixir community. We'd love for you to join us!
We're excited and proud to announce our keynote speakers for the second annual EMPEX!
Jessica Kerr is a developer in many functional languages: Scala, Elm, Clojure, Ruby (OK, not a functional language but principles still apply). Lately she is excited about distributed systems, infrastructure, and automating our automation. In between working remotely and speaking at conferences worldwide, Jessica raises two daughters in St. Louis, MO.
Dr Eugenia Cheng is a mathematician and pianist. She is Scientist In Residence at the School of the Art Institute of Chicago and won tenure in Pure Mathematics at the University of Sheffield, UK. She is now Honorary Fellow at the University of Sheffield and Honorary Visiting Fellow at City University, London. She has previously taught at the universities of Cambridge, Chicago and Nice and holds a PhD in pure mathematics is from the University of Cambridge.
Alongside her research in Category Theory and undergraduate teaching her aim is to rid the world of "math phobia". Her first popular math book, How to Bake Pi, was published by Basic Books in 2015 to widespread acclaim including from the New York Times, National Geographic, Scientific American, and she was interviewed around the world including on the BBC, NPR and The Late Show with Stephen Colbert. The book is being translated into eight languages so far. Eugenia was an early pioneer of math on YouTube and her videos have been viewed over a million times to date. She has also assisted with mathematics in elementary schools and high schools for 15 years. Her next popular math book Beyond Infinity will be published in 2017 and is already being translated into three languages.
Eugenia recently received her first commission for mathematical artwork, and is designing chalkboard installations for the new science themed Hotel EMC2 in Chicago, commemorating Emmy Noether and symmetry. Eugenia is also a concert pianist and runs the Liederstube, a Not For Profit organization in Chicago bringing classical music to a wider audience.
We're proud to announce the following presentations for EMPEX!
Monitoring Production Elixir Applications
You just celebrated the launch of your first production elixir application and now have real users using your application. In this talk, you'll learn how to measure and monitor your elixir application as your user base grows from hundreds of daily users to millions. With more users comes more revenue, but also more technical challenges as you go from one server to many. And 'tail –f' is no longer useful when the logs are going by faster than you can read or the requests are load balanced across many servers. In this talk you'll learn the best practices for monitoring your applications in a way that will scale as you grow. Best of all these practices are universal, so they will be applicable if your organization is solely in the BEAM world or if you're are in a polyglot environment. Lastly, you'll learn about to measure availability in the context of web applications and how many nines of availability your API has.
About John: John is a mostly autodidact programmer who writes with Elixir, Ruby, Go, or Clojure. He's a former Ruby developer/manager who now works almost exclusively with Elixir at Bleacher Report. His current work involves using Elixir with Neo4j and Apache Kafka.
The BEAM, the official Erlang VM implementation, is the most important piece of the puzzle in the Elixir ecosystem. It provides some strong guarantees which minimize or completely remove some classes of problems and simplify implementation of fault-tolerant systems. It is the foundation which makes all other things in the ecosystem possible. The OTP framework, as well as third party libraries and frameworks, such as Phoenix, Ecto, or Nerves, make most sense when running on top of BEAM. Replace BEAM with something else, and you'll lose some important guarantees, which in turn can make your life much more complicated. In this talk we’ll take a closer look at a couple of seemingly simple, yet very powerful properties of BEAM, focusing in particular on some aspects of its lightweight concurrency. Going further, we’ll explore how OTP builds on top of these guarantees to bring us reliable higher-level abstractions such as supervisors. For good measure, there will be a couple of demos to make these claims more concrete.
About Saša: Happy user of Elixir, and a satisfied customer of Erlang/OTP, currently working on a privacy compliance solution at Aircloak. Author of "Elixir in Action", and occasional blogger at theerlangelist.com.
Travis Vander Hoop
Channels as Controllers (An Exercise in Refactoring)
Phoenix Channels are one of the framework's best features, making real-time applications a snap. But what happens when a channel's responsibilities grow to the point of ill-repute? We'll look at the evolution of a single Phoenix Channel implementation over the course of several small and related features, and we'll see what patterns Elixir developers can leverage to keep their Channels skinny.
About Travis: Travis is a software developer at Stride Consulting. He digs Elixir, really, really digs Phoenix, and is always looking for a better way to do things.
Understanding Elixir's (re)compilation
Elixir's code-generation capabilities require a sophisticated compiler with complex dependency tracking. Given such complexity, it is often unclear why sometimes changing a single line in a single file triggers the recompilation of a hundred others. In this talk we are going to take a deep dive into what happens when you type "mix compile" with the aim of clarifying what is happening.
About Renan: Renan is currently working full time with Elixir and Clojure at Xerpa, an HR platform startup in Brazil. He survived a big-scary-rewrite and has changed language a dozen times. In a previous life, he was also a Chemical Engineer.
Seussical Halting, Indeterminate Faulting
The halting problem is a classical concept in computer science. In "Scooping the Loop Snooper," Geoffrey K. Pullum wrote a wonderful general proof of it, entirely in Dr. Seuss-style verse. In this talk we examine the core principles of the paper, in the same style (to the best of my ability), while working in IEx.
About Bobby: Bobby is a developer who yells at computers for Wombat Security Technologies. Beginning in C/PHP/Python, he has since walked into the world of Ruby and ended up seeing the light of Elixir and Erlang some years ago and has not looked back. In his downtime, he wears loud pants, travels with his awesome partner in crime, and yells at computers more.
When Does Concurrency Pay Off?
This talk explores concurrency in Elixir at many different scales. From parsing simple strings to unleashing an army of workers to fetch, decode, and store data — at what scale does the overhead of using concurrent computing make sense? This talk presents the findings of someone using Elixir at his day-job where performance isn't a luxury but oftentimes a requirement.
About William: William is working at a startup in NYC, Urbint, writing production Elixir code. Before that he was working for Google building ThinkWithGoogle.com. When not writing Elixir, William's interests include eating sushi, fiddling with Haskell, and learning to play Go.
Everything Beautiful is in Plug
Elixir's Plug is a library of code that demonstrates the best of the language. We'll look at the anatomy of the library and do a deep dive into Plug Router and discuss interesting functions, especially
compile/4, which demonstrates the gold standard for implementing macros. Finally, we'll hear some recommendations that can help each of us write great macros.
About Omid: Omid is a developer at Mojotech in Providence, RI. His background is in Ruby and in teaching people how to program. When he's not learning or coding, he's chasing after his two crazy kids. And that's all there is time for.
Functional Data Structures
Most developers learn data structures in the context of imperative or object oriented languages. Chris Okasaki, in "Purely Functional Data Structures," proved that they can be written from a functional perspective, but his examples are steeped in ML/Haskell semantics. We will take the functional data structures of Okasaki and others, explain them in Elixir terms, and show their practical uses and performance implications. We will aim to be as 'real world' as possible while showing Elixir's capability to go beyond the standard library data structures. And we'll see how its semantics favorably support functional data structures.
About Juan: Juan is an engineer at Capsule and attended the Recurse Center, where he studied functional and distributed programming with Erlang, Elixir, and a bit of Haskell. After work, Juan likes to read about art history and make coffee with his Chemex.
Training tickets are available here.
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.
Finally, we will introduce the Elixir concurrency model. If your experience of concurrency consists of threads, mutexes, and critical sections, you will be amazed at the simplicity of building reliable concurrent systems using Elixir and OTP.
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.
OTP: OTP is a powerful framework developed for Erlang, and battle-hardened after 30 years of continuous ongoing development. A complete view of OTP is beyond the scope of this course, but we will introduce the high level concepts.
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.
The intermediate / advanced Elixir training will help those familiar with the Elixir language pickup the skills of how to work with and model applications using Processes and the OTP library.
In this course we will take a complex real-world problem and use a variety of tools and techniques to solve it. Along the way we'll cover:
- Structuring applications using an umbrella app
- Keeping state in GenServers / Agents / ETS tables
- Thinking in Processes to solve the problem at hand
- Using Supervision trees to create resilient programs that can recover from failure
- Testing our work as we go using isolated unit tests and integration tests
You'll come away from this course with a clear understanding of how to apply these concepts to your next Elixir project as well as a repository and source material that you can reference in the future.
The course will be taught by two Elixir veterans; Chris Bell and David Antaramian.
Training tickets are available here.