Code Mesh 2017: Day 1 review

by Ricardo Goncalves

Before you go any further, you should know that Code Mesh is now a part of Code Sync, our new family of global tech conferences. Learn more ->

This year’s Code Mesh saw the conference go from strength to strength. So much so, I couldn’t fit the highlights from the entire conference in a single blog post.

So here’s my take on the talks I attended on day one of Code Mesh 2017:

Keynote: Automatically Scalable Computation — Margo Seltzer

Speaker: Margo Seltzer, (at the time) Herchel Smith Professor of Computer Science and the Faculty Director for the Center for Research on Computation and Society in Harvard’s John A. Paulson School of Engineering and Applied Sciences

This was the first keynote of CodeMesh and what a way to start. The main question was basically: “Can programs get better at running programs with practice?”

The idea seems far-fetched and even Margo herself said that initially she thought the idea (coming from a young student) was a bit “naive”, in the sense that it was not possible and/or practical.

Also keep in mind that she was talking about feeding the same program to the computer and it ran faster with time, and not some higher-level “neural network/deep learning” middleware that was being used.

This idea works on the lowest level possible, the bits and bytes running inside your CPU, and it’s like branch prediction on steroids, where the program execution is divided in smaller parts and pre-computed (possibly in different cores). Over multiple runs, heuristics are built for that program that make these pre-computation somewhat accurate, depending on the program itself.

Some of the benchmarks were pretty amazing, but to truly that this to the next step, it seems like hardware-support will be needed from the CPU.

There is a lot more to it than this, but suffices to say that it was a great beginning to CodeMesh.

A Practical Functional Relational Architecture: Building Systems with Datomic — David Nolan

Speaker: David Nolan, Software Engineer at Cognitect

David Nolan gave us a pretty good talk on immutability on the database with Datomic.

Most of the talk was motivation for why we should care for an immutable database, which makes sense, since actually using one (like Datomic) seems pretty straightforward, given that you can’t screw up your data :)

He argued that immutability, a characteristic of functional programming, was already an option on the front-end with technologies like React or ClojureScript (which Nolan is the creator) and on the back-end with functional languages (Erlang, Clojure, Haskell, etc.). This leaves the database as the odd one out.

Datomic was born from that sentiment of bring the benefits of immutability for the entire stack. The live demo where Nolan trivially queried data from the past was also nice (and seems really useful for auditing, etc.).

As an interesting side note, Datomic can actually delete data due to legal reasons.

Beyond Eventual Consistency (FaunaDB, Calvin) — Jamie Allen

Speaker: Jamie Allen, Director of Engineering for the Unified Commerce Project at Starbucks

Jamie is the head of engineering at Starbucks, a company with a global presence, so you can imagine the scale at which they deal in their systems / databases.

When he arrived at Starbucks, Cassandra was the DB of choice. But it turns out that eventual consistency is not ideal for every use case, and in particular for some the uses that Starbucks has (which I believe is the reward program that customers can sign-up for).

So the engineering team lead by Jamie started their journey on finding a replacement for Cassandra that provided stronger guarantees than eventually consistency.

He also argued that the CAP theorem is still misunderstood and maybe not the best way to frame the problem of data consistency, availability, etc.

He suggests to use the PACELC theorem instead. The rest of the talk was a small review of the options that they looked at for their next DB: Amazon Aurora, Microsoft Cosmos, Google Spanner, CockroachDB and finally FaunaDB, which seems like the current option, based on internal evaluation.

Metaphors We Compute By — Alvaro Videla

Speaker: Alvaro Videla, former Core Developer for RabbitMQ and co-authored the book “RabbitMQ in Action”

Video coming soon. Subscribe for notifications.

Alvaro gave a pretty different talk, one which most non-technical people could see, follow along and appreciate.

Alvaro took inspiration from the book “Metaphors We Live By”, and produce an article for ACM Queue. The talk was based on that article.

The main point is that we as people think and process things using metaphors (or abstractions) all the time. For example, we may start learning mathematics with simple examples for counting, which is a metaphor / abstraction of the underlying mathematical concept.

And we build on that over the years to other levels of the abstraction, using different metaphors. And software developers do the same, using different metaphors for all kind of problems (e.g. “Rumor Mongering” or “Gossiping”).

The bottom line is that we should be aware of these metaphors and choose the right ones for the situation. A less technical talk that gave a well-rounded feel to a tech-conference like CodeMesh.

Pony for Safe, Fast, Concurrent Programs — Sophia Drossopoulou

Speaker: Sophia Drossopoulou, Professor in Programming Languages at Imperial College London.

Video coming soon. Subscribe for notifications.

Sophia gave an interesting talk on a emerging language called Pony. It is an Actor-based language like Erlang or Elixir, but compiles to native code.

It also has a pretty innovative type system, which was the focus of this talk. All types and their respective rules can seem a bit intimidating for beginners, but Sophia says that you get used to it pretty quick. The good this is that this type systems gives you a lot of guarantee that you can’t find in most languages like: safe mix of mutable and immutable data, data-race free and efficient programs.

Similar to Erlang/Elixir, it has a Garbage Collection mechanism that runs per-process concurrently, without distributed locks.

I found it interesting that it also supports (or needs?) causal delivery for messages between actors, something rarely seen at a language level.

Everything is Terrible — Fred Hebert

Speaker: Fred Hebert, author of ‘Learn You Some Erlang for Great Good!’ and ‘Erlang in Anger’, and system architect at Genetec.

Video coming soon. Subscribe for notifications.

This is the perfect talk to watch if you want to have some laughs and also feel a bit sad at the state of software.

Fred goes through a journey of multiple software abstractions of everyday software that we all use sooner or later.

He emphasised six “terrible” topics: Data Structures, Time, IDs, Numbers, String/Text and Network. This is a talk that is clearly better to watch than to read some short summary like this.

But essentially, the touched on horror stories involving: floating-pointer precision, UUIDs (lack of standardisation), queues/microservices (asynchrony is hard), JSON (every parser is different), time and time-zones, leap seconds, unicode mess and the (in)security of software.

Watch more videos from Code Mesh 2017 or learn more about Code Sync, our new family of global tech conferences which now includes Code Mesh.

Originally published at www.erlang-solutions.com.