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.
Miriam and Robert Virding
Miriam and Irina Guberman
Miriam and Andrew Thompson
Miriam and Lennart Öhman
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:
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:
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:
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:
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:
Joe DeVivo talked about a composable modeling scheme for 3D printing with Elixir.
Fred Hebert talked about what we like and what we hate about Erlang… plus he did it upside down on his laptop:
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
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
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,
@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.
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!