Emerald is an arcane, general-purpose programming language, designed in the early- to mid-1980s in an academic effort to address the challenge of distributed programming. Emerald was designed in the pre-Internet, pre-Java, pre-smartphone era. It has gained little adoption, and so is only piecewise applicable in modern distributed settings. Never-the-less Emerald offers a distinct distributed programming model, worthy of further investigation.

Emerald is a statically-typed, object-based, garbage-collected, language; with distributed programming primitives that provide for fine-grained mobility and location transparency. One questionable element of the state of affairs, is that Emerald uses a dedicated virtual machine for executing dedicated Emerald bytecode.

Erlang is another general-purpose programming language; designed in the late 1980s to early 1990s, in an industrial effort to address the challenge of programming telephone switches. Originally developed at Ericsson, it was open-sourced in the late 1990s, and continues to be actively used and maintained.

It turns out, that programming telephone switches has a lot in common with distributed programming, in general. Today, Erlang is consistently ranked among the top-100 programming languages according to the TIOBE index; and continues to make distributed systems headlines.

If we had to write a single-sentence description of Erlang, it would differ from the one about Emerald only in that it is functional, dynamically-typed, and actor-based. However, static typing is also actively making its way into the Erlang ecosystem. Hence, the only real difference is that Erlang is functional and actor-based, while Emerald is imperative and object-based.

Erlang too, rolls its own virtual machine, called BEAM. BEAM is a garbage-collected, reduction counting, non-preemptive, register-based virtual machine, with primitives reminiscent of an actor-based language. Due to Erlang’s popularity, it is a mature and robust virtual machine for hosting distributed programming languages, in general. Several languages exist to address supposed problems in the Erlang programming model, while still leveraging BEAM (e.g., Elixir, Alpaca, Lisp-Flavoured Erlang, Joxa).

In this talk, I will present the Emerald programming model, the inevitable runtime needs of this model, and present ongoing work to leverage BEAM to provide an efficient and robust runtime system for Emerald. As such, this will be an investigation of the runtime differences between imperative objects and functional actors. In-so-doing, I also present yet another statically-typed language for writing BEAM-compatible software.