CodeBeam SF 2018: Erlang and Elixir in production

Steve Wight Written by Steve Wight, April 12, 2018

Highlights from the CodeBeam SF 2018 conference, March 15-16 2018

Once was Erlang Factory

The name has changed - yearly in fact, for the past few years - but this conference is always a destination for the Erlang faithful. The premise has been broadened since the Erlang Factory days of yore to welcome other BEAM based languages, the most prominent of those being Elixir of course, but worthy mentions here are LFE (Lisp Flavored Erlang) as well as the more experimental efforts happening: Erlog, Clojerl, Luerl, Efene, and Alpaca. I find the big tent to be a really great thing for the Erlang ecosystem in general. It’s good to be reminded that one of the lasting beauties of Erlang is the reusability and relevance of BEAM itself to the networked world we work in.

The subplot this year is a good one: 2018 marks the 20th year since Ericsson first released Erlang as open source! This has had much positive influence on the lifetime of this language and BEAM.


The two-day conference featured 50 speakers in all, with two keynotes each day. The organizers, Code Sync, have merged the long-running Erlang Factory event series under their umbrella in the past year, alongside the Code Elixir and Code Mesh series. This seems to have worked out well. The Code Beam conference certainly went very smoothly - the scheduling made sense, presentation technology worked properly, and the volunteers were knowlegeable and helpful. I should note the integration of the Whova app for navigating around between talks, the darned thing actually worked really well.

The conference was organized into six themes: introductory tutorials and overviews of the Erlang ecosystem; the state of the BEAM toolset for production environments. deployment, maintenance, monitoring, and testing; case studies in high reliablity system building; in-depth BEAM topics, including compiler implementation issues, language extensions, and active areas of research; frameworks including Phoenix, RabbitMQ, Nerves, MongooseIM and others; and last but far from least distribution, concurrency, multicore and functional programming in the Erlang ecosystem.

The following list of highlights is fairly randomly chosen across those tracks, as there were quite a few contenders. This is just a sampling of talks that struck me as particularly memorable - a number of solid tutorials and more general reflections are skipped here. I highly recommend paging through the full set of recorded talks on on youtube.

#OpenErlang Party

The organizers celebrated 20 years of open source Erlang by throwing a very nice bash at Galvanize the first evening. Miriam worked the room:

Miriam and Robert Virding


Miriam and Irina Guberman


Miriam and Andrew Thompson


Miriam and Lennart Öhman


AdRoll Content

I was most excited about the representation by AdRoll among the speakers, unsurprisingly! Three members of the RTB team spoke, with an eye-opening historical keynote about the significant but infrequently-mentioned contributions of women to the development of Erlang and OTP (Open Telecom Platform) from our own Miriam Pena:

Also on the first day, our own Brujo Benavides delivered a solid rationale for the practice of using opaque (module-scoped) data types in Erlang code, for maintainability and readbility reasons:

And of course Mike Watters described his recent rewrite of the RTB profile cache system using Elixir and the Flow framework, which increased peak throughput by 2X on that critical system (described in his blog post here as well):

The usual suspects

An Erlang convocation is not really complete without a keynote from Joe Armstrong needless to say. We were treated to a customary eclectic dilation on topics arcane, perhaps best described as a paleobiological view across the brief decades since computer science became a thing… not unlike a peek at the Burgess Shale, but for computers:

Robert Virding always has something fascinating to say and he joined with Mariano Guerra to present a survey of some language implementation projects based on BEAM, along the way describing the contortions big or small that these involved:

Naturally I have to mention fabulous Fred Hebert, scribe and scholar responsible for must-have references Learn You Some Erlang For Great Good and Erlang in Anger, who talked about the importance of using supervisor trees to prepare for and gracefully handle unexpected complex failures in distributed systems:

My introduction to property based testing came via Kostis Sagonas in his talk about PropEr, Concuerror and using optimal partial order reduction to find outlier bugs in your code without waiting 48 days for naive exhaustive tests to complete:

Scott Lystig Fritchie talked about why he isn’t using Erlang at Wallaroo Labs - the answer is Pony and it’s complicated:

Raimo Niskanen walked us through the gen_statem OTP behaviour class, introduced in OTP 19.0, which simplifies the API surface of the original gen_fsm behaviour while at the same time adding a significant amount of extra functionality and ease of use:

File under…

Andrew Thompson described a IoT-to-cloud communications scheme implemented largely in Erlang (in software and firmware) on Helium’s low-power bidirectional 802.15.4 based radio module, the Atom - which operates using a variation of blockchain architecture based on ‘proof of coverage’ rather than the unwieldy ‘proof of work’ most of us think of when talking about blockchains:

Irina Guberman gave an in-depth look at the decisions her team made while implementing distributed mutable counters for metrics:

Emma Cunningham, who was a formal semanticist before joining the engineering world, began a review of the mathematical and philosophical origins of type theory with the memorable sentence, “I’ve been a functional programming advocate since before I became a software engineer” - she concludes with a compelling argument to just use Dialyzer for all the things:

An overview of AMQP and RabbitMQ, the poster child for Erlang implementations in the wild, was given by Brett Cameron:

Lastly I include a fun talk given by Simon Thompson that describes a very functional approach to implementing lazy evaluation - it’s a great idea for an interview problem too:

Lightning talks

Brujo Benavides talked about SpawnFest (mostly… okay he also proselytized for ROK style leading commas in your source, but we love him anyway):

Joe DeVivo talked about a composable modeling scheme for 3D printing with Elixir.

Mariano Guerra talked about many things, including Efene and a call for polyglot ADTs over BEAM.

Erik Stenman talked about using HiPE inspection tools to peer at Erlang’s innards.

Fred Hebert talked about what we like and what we hate about Erlang… plus he did it upside down on his laptop: fred-upside-down

Updates from the mothership

Naturally we were treated to the latest state of the union announcements from the Erlang and Elixir support teams:

Update: OTP 21.0

Raimo Niskanen talked about the changes coming up in OTP:

OTP 21.0 is due out June 20 2018 - we’re looking forward to full stack traces from exceptions, optimized small maps, the introduction of the logger module, and I personally am delighted to see lists:search(List, fun/1) added to the lists module! Don’t judge me.

Interesting mentions in the “Longer term plans” segment of Raimo’s summary: more compiler optimizations using Single Static Assignment representation, profiling tool improvements, Erlang Language Server Protocol to get support for Erlang in common editors, oh and the unicorn was spotted - sorry, the JIT compiler is approaching HiPE performance now…

Update: Elixir 1.6

James Fish walked us through the significant developments in Elixir 1.6:

The Elixir team is focusing on productivity, maintainability, reliability… Version 1.6 features a go fmt style code formatting module, which is good for all the reasons that a stable and universal source code format is good. It is callable from code and from the command line. The AST has been surfaced with an API and some utilities that will allow term structure of code to be inspected easily. require/1,2 has been added to notify one’s compiler and one’s self about [in particular] macro dependency relations. Two new attributes, @deprecated and @since, mark whether a function or macro is deprecated and when that happened. defguard/defguardp generate macros suitable for use in guard expressions, enhancing readbility. DynamicSupervisor is a new behaviour, or more precisely a reformed behaviour, and I quote James here: “A replacement for simple_one_for_one, but actually simple”

Plans for the subsequent major release at the end of 2018 (1.7) include a mix which will generate releases, a new PBT tool called StreamData which does data generation and simple PBT, better Dialyzer support, and greatly improved documentation.

Last thoughts

As usual I’m invigorated by attending this conference. The breadth and depth of work being done using BEAM is remarkable - IoT/Edge netorks/embedded applications, language-agnostic testing frameworks, high performance low-latency distributed computation… Erlang and its progeny have passed through a number of major paradigm shifts in this industry and seem to always stay relevant, somehow offering something new even as the tech stack grows broader and deeper.

It is always a good feeling to be present at a tech conference when you have a horse in the race - and in this case Adroll very much does, being prominent Erlang proponents and users. It seems self-evident that showing up and participating is a vital part of selling our technology and engineering culture to our peers, and that can only be a good thing, if for no other reason than helping attract motivated and informed people to our team!

Are you interested in working with Erlang and Elixir in a high-performance globally distributed environment? Roll with Us!