ICFP 2016 Workshops
21st ACM SIGPLAN International Conference on Functional Programming (ICFP 2016)
Powered by
Conference Publishing Consulting

15th International Workshop on Erlang 2016 (Erlang 2016), September 23, 2016, Nara, Japan

Erlang 2016 – Proceedings

Contents - Abstracts - Authors

15th International Workshop on Erlang 2016 (Erlang 2016)


Title Page

Message from the Chairs
It is our great pleasure to welcome you to the Fifteenth ACM SIGPLAN Erlang Workshop – Erlang’16. This year’s workshop continues the tradition of being co-located with the annual International Conference on Functional Programming (ICFP), and being a forum for the presentation of research efforts and experience reports on all aspects of theory, implementation and applications of the Erlang and Erlang-like programming language and related technologies, such as functional programming, distribution, concurrency, scalability, etc. The Erlang model of concurrent programming has been widely emulated, for example by Akka in Scala, and even new programming languages have been designed atop of the Erlang VM, such as Elixir. Therefore, we would like to broaden the scope of the workshop to include systems like those mentioned above, and we are pleased to include a publication on profiling in Akka. The call for papers attracted a total of 9 submissions (7 full papers and 2 experience reports), each of them carefully reviewed by at least three program committee members. The program committee accepted 5 of those submissions as full papers and 2 as experience reports. In addition, we are pleased to include in the proceedings 2 poster presentation papers. Moreover, the steering committee invited a keynote presentation by Maria del Mar Rubio Gonzalez, Equal Experts UK Ltd.

Research Papers

The Nifty Way to Call Hell from Heaven
Andreas Löscher and Konstantinos Sagonas
(Uppsala University, Sweden)
Often Erlang programmers want or need to use existing C libraries. Also, occasionally they have good reasons to implement parts of their applications directly in C. To cater for such situations, the Erlang/OTP system comes with various mechanisms to call C from Erlang. The most modern of them allows to call C functions from Erlang as natively implemented functions (NIFs). Unfortunately, the use of a NIF library currently requires writing by hand a fair amount of code that to a large extent is boilerplate. To ease the lives of Erlang programmers and simplify the task of using existing C code bases from Erlang, we have created Nifty, a tool that automates the process of creating NIF libraries from C header files containing declarations of types and functions that the library supplies. This paper describes the functionality and implementation of Nifty, its current limitations and our experiences with it so far.
Publisher's Version Article Search
Towards Reliable and Scalable Robot Communication
Andreea Lutac, Natalia Chechina, Gerardo Aragon-Camarasa, and Phil Trinder
(Glasgow University, UK)
The Robot Operating System (ROS) is the de facto standard platform for modern robots. However, communication between ROS nodes has scalability and reliability issues in practice. In this paper, we investigate whether Erlang's lightweight concurrency and reliability mechanisms have the potential to address these issues. The basis of the investigation is a pair of simple but typical robotic control applications, namely two face-trackers: one using ROS publish/subscribe messaging, and the other a bespoke Erlang communication framework. We report experiments that compare five key aspects of the ROS and Erlang face trackers. We find that Erlang communication scales better, supporting at least 3.5 times more active processes (700 processes) than its ROS-based counterpart (200 nodes) while consuming half of the memory. However, while both face tracking prototypes exhibit similar detection accuracy and transmission latencies with 10 or fewer workers, Erlang exhibits a continuous increase in the total time taken to process a frame as more agents are added, and we identify the cause. A reliability study shows that while both ROS and Erlang restart failed computations, the Erlang processes restart 1000--1500 times faster than ROS nodes, reducing robot component downtime and mitigating the impact of the failures.
Publisher's Version Article Search
Profiling Actor Utilization and Communication in Akka
Andrea Rosà, Lydia Y. Chen, and Walter Binder
(University of Lugano, Switzerland; IBM Research, Switzerland)
Several programming languages and frameworks offer actor-based concurrency inspired by Erlang. Among them, Akka has been adopted in numerous applications and frameworks running on the Java Virtual Machine. Unfortunately, despite the spread of Akka-based applications, there are few dedicated profilers. In this paper, we aim at filling this gap by presenting a novel profiling tool for Akka applications. In contrast to existing profilers for Akka, our tool focuses particularly on actor utilization and on the communication between them. We evaluate our tool on various applications and frameworks in both parallel and distributed settings, such as Signal/Collect, Apache Spark and Apache Flink. Our results show that our profiler helps understanding actor utilization, investigating load balancing in computing frameworks, and analyzing communication performance in the message exchange process.
Publisher's Version Article Search
A Scalable Reliable Instant Messenger using the SD Erlang Libraries
Natalia Chechina, Mario Moro Hernandez, and Phil Trinder
(Glasgow University, UK)
Erlang has world leading reliability capabilities, but while it scales extremely well within a single node, distributed Erlang has some scalability issues. The Scalable Distributed (SD) Erlang libraries have been designed to address the scalability limitations while preserving the reliability model, and shown to deliver significant performance benefits above 40 hosts using some relatively simple benchmarks. This paper compares the reliability and scalability of SD Erlang and distributed Erlang using an Instant Messaging (IM) server benchmark that is a far more typical Erlang application; a relatively large and sophisticated benchmark; has throughput as the key performance metric; and uses non-trivial reliability mechanisms. We provide a careful reliability evaluation using chaos monkey. The key performance results consider scenarios with and without failures on up to 17 server hosts (272 cores). We show that SD Erlang adds no performance overhead when all nodes are grouped in a single s_group. However, either adding redundant router nodes in distributed Erlang applications, or dividing a set of nodes into small s_groups in SD Erlang applications, have small negative impact. Both the distributed Erlang and SD Erlang IM tolerate failures and, up to the failure rates measured, the failures have no impact on throughput. The IM implementations show that SD Erlang preserves the distributed Erlang reliability properties and mechanisms.
Publisher's Version Article Search
CRDTs for the Configuration of Distributed Erlang Systems
Viktória Fördős and Francesco Cesarini
(Erlang Solutions, Hungary; Erlang Solutions, UK)

CRDT (Conflict-free replicated data type) is a data type that supports conflict free resolution of concurrent, distributed updates. It is often mentioned alongside storage systems that are distributed, fault-tolerant and reliable. These are similar properties and features of Erlang/OTP systems. What distributed Erlang/OTP systems lack, however, is a standardised way to configure multiple nodes. OTP middleware allows you to set configuration parameters called application environment variables on a node basis, they can be updated at runtime, but will not survive a restart unless persisted in the business logic of the system. There is no widely adopted solution to address this omission. In some installations, changes are done manually in the Erlang shell and persisted by editing the configuration files. In others, changes and updates are implemented as part of a new releases and deployed through an upgrade procedure. These tools expect a happy path, and rarely take network failures and consistency into consideration. As a result, issues have been known to cause outages and have left the system in an inconsistent state, with no automated means of detecting the root cause of the problem.

In this paper, we introduce a configuration management approach designed for distributed Erlang/OTP systems. They are systems which often trade consistency for availability and scalability, making them a perfect fit for CRDTs. We use a proprietary tool called WombatOAM to update environment variables and check their consistency on both node and cluster-levels. Inconsistencies and failed updates are detected and reported in the form of an alarms, and the history and status of all performed changes are logged, facilitating troubleshooting and recovery efforts.

In this paper, we show our approaches to configuration management, and discuss how we approached the issue of consistency in the presence of unreliable networks. We present a qualitative evaluation and a case study to assess the capabilities of WombatOAM’s CRDT based configuration management feature.

Publisher's Version Article Search

Experience Reports

Observing the Consistency of Distributed Systems
Deepthi Devaki Akkoorath, Viktória Fördős, and Annette Bieniusa
(University of Kaiserslautern, Germany; Erlang Solutions, Hungary)
In distributed Erlang systems temporary network issues are very likely; and can affect the consistency of the system. If the system is a distributed data store relying on a weak consistency model, its data stored may diverge as a result of connectivity issues. Even worse, there is no indicator of the divergence. In this paper we present our initial work on divergence metrics and give a preliminary evaluation on exposing divergence to the system operator.
Publisher's Version Article Search
Making Everybody Comfortable with Erlang: A SCADA System for Thermal Control
Laura M. Castro, J. Daniel Fernández, and Carlos López Pampín
(University of A Coruña, Spain; Arce Clima, Spain)
SCADA systems are a kind of industrial control systems which remotely monitor and even operate signal-emitting components, typically those involved in physical industrial processes. SCADA systems have been around for decades, but with the popularization of the so-called ‘Internet of Things’ (IoT) they reach a whole new dimension: managing not tens, but tens of thousands of components. Consequently, the application of new technologies that can cope with this change acquires specific relevance. In this work, we postulate Erlang/OTP as a very suitable technology to build a SCADA system, and we present the use case in which we are testing this in practice. We also discuss the expectations in terms of concurrency and distribution, two of Erlang’s widely recognized strengths, that we intend to meet.
Publisher's Version Article Search

Poster Presentations

Automatic Generation of UML Sequence Diagrams from Test Counterexamples
Daniel Carballa and Laura M. Castro
(University of A Coruña, Spain)
Software testing activities involve two main challenges: the first is the design of test cases that will reveal failures; the second is the debugging of the software under test to identify and remove the source of the revealed failures. While a lot of effort from the research community is put in the former, the latter does not seem to attract the same amount of interest from academia, which we could say, in a way, means disregarding half of the quality software building process. In this paper, we present a methodology --and tool support-- to automatically transform test counterexamples, as produced by test automation tools like QuickCheck, into UML sequence diagrams. These are intended to ease debugging, and improve both documentation and communication between stakeholders of the software development process.
Publisher's Version Article Search
Towards Semi-automatic Data-Type Translation for Parallelism in Erlang
Adam D. Barwell, Christopher Brown, David Castro, and Kevin Hammond
(University of St. Andrews, UK)
As part of ongoing research into programmer-in-the-loop parallelisation, we are studying the problem of automatically introducing alternative data structures to support parallelism. Our goal is to make it easier to produce the best parallelisation for some given program, or even to make parallelisation feasible. We use a refactoring approach to choose and introduce these transformations for specific algorithmic skeletons, structured forms of parallelism that capture common patterns of parallelism.
Publisher's Version Article Search

proc time: 0.02