SPLASH Workshops 2018
2018 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Workshops 2018)
Powered by
Conference Publishing Consulting

8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE 2018), November 5, 2018, Boston, MA, USA

AGERE 2018 – Proceedings

Contents - Abstracts - Authors

8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE 2018)

Frontmatter

Title Page

Message from the Chairs
Welcome to the proceedings of the 8th International Workshop on Programming based on Actors, Agents, and Decentralized Control (AGERE!), co-located with SPLASH 2018. AGERE!, an ACM SIGPLAN workshop, keeps on being a unique venue in the research landscape bringing together researchers and practitioners interested in actors, agents and, more generally, high-level paradigms emphasizing decentralized control in thinking, modeling, developing, and reasoning about software systems.

Distributed Systems

A Configurable Transport Layer for CAF
Raphael Hiesgen, Dominik Charousset, and Thomas C. Schmidt
(Hamburg University of Applied Sciences, Germany)
The message-driven nature of actors lays a foundation for developing scalable and distributed software. While the actor itself has been thoroughly modeled, the message passing layer lacks a common definition. Properties and guarantees of message exchange often shift with implementations and contexts. This adds complexity to the development process, limits portability, and removes transparency from distributed actor systems. In this work, we examine actor communication, focusing on the implementation and runtime costs of reliable and ordered delivery. Both guarantees are often based on TCP for remote messaging, which mixes network transport with the semantics of messaging. However, the choice of transport may follow different constraints and is often governed by deployment. As a first step towards re-architecting actor-to-actor communication, we decouple the messaging guarantees from the transport protocol. We validate our approach by redesigning the network stack of the C++ Actor Framework (CAF) so that it allows to combine an arbitrary transport protocol with additional functions for remote messaging. An evaluation quantifies the cost of composability and the impact of individual layers on the entire stack.
Publisher's Version Article Search
Distributed Functional Reactive Programming on Actor-Based Runtime
Kazuhiro Shibanai and Takuo Watanabe
(Tokyo Institute of Technology, Japan)
Reactive programming over a network is a challenging task because efficient elimination of temporary violations of data flow invariants, known as glitches, in a distributed setting is still an open issue. In this paper, we propose a method for constructing a distributed reactive programming system of which runtime guarantees the properties of single source glitch-freedom and the robustness against out-of-order messages. Based on the method, we developed a purely functional reactive programming language XFRP whose compiler produces Erlang code. Using some examples, we show that the proposed method is beneficial for constructing distributed reactive applications without suffering from inconsistencies.
Publisher's Version Article Search
Observable Atomic Consistency for CvRDTs
Xin Zhao and Philipp Haller
(KTH, Sweden)
The development of distributed systems requires developers to balance the need for consistency, availability, and partition tolerance. Conflict-free replicated data types (CRDTs) are widely used in eventually consistent systems to reduce concurrency control. However, CRDTs lack consistent totally-ordered operations which can make them difficult to use. In this paper, we propose a new consistency protocol, the observable atomic consistency protocol (OACP). OACP enables a principled relaxation of strong consistency to improve performance in specific scenarios. OACP combines the advantages of mergeable data types, specifically, convergent replicated data types, and reliable total order broadcast to provide on-demand strong consistency. By providing observable atomic consistency, OACP avoids the anomalies of related protocols. We provide a distributed implementation of OACP based on Akka, a widely-used actor-based middleware. Our experimental evaluation shows that OACP can reduce coordination overhead compared to other protocols providing atomic consistency. Our results also suggest that OACP increases availability through mergeable data types and provides acceptable latency for achieving strong consistency.
Publisher's Version Article Search

Parallel Systems

Chocola: Integrating Futures, Actors, and Transactions
Janwillem Swalens, Joeri De Koster, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
Developers often combine different concurrency models in a single program, in each part of the program using the model that fits best. Many programming languages, such as Clojure, Scala, and Haskell, cater to this need by supporting different concurrency models. However, they are often combined in an ad hoc way and the semantics of the combination is not always well defined. This paper studies the combination of three concurrency models: futures, actors, and transactions. We show that a naive combination of these models invalidates the guarantees they normally provide, thereby breaking the assumptions of developers. Hence, we present Chocola: a unified framework of futures, actors, and transactions that maintains the guarantees of all models wherever possible, even when they are combined. We present the semantics of this model and its implementation in Clojure, and have evaluated its performance and expressivity using three benchmark applications.
Publisher's Version Article Search Info
Concurrent Garbage Collection in the Actor Model
Dan Plyukhin and Gul Agha
(University of Illinois at Urbana-Champaign, USA)
In programming languages where memory may be allocated dynamically, automatic garbage collection (GC) can improve the efficiency of program execution while preventing program errors caused by incorrectly removed memory locations. In actor systems, GC poses some challenges that make it much costlier than in the sequential setting: Besides references from reachable actors, we have to consider inverse references from potentially active actors to reachable actors. One proposal, adopted in the runtime for the actor programming language Pony, uses causal message delivery and a centralized detection algorithm. While this is efficient in a multicore setting, the solution is too expensive for a distributed actor runtime. In this work, we show how the causal order message delivery requirement may be removed. Specifically, we describe a tracing collector of distributed actor garbage with centralized and decentralized variants. Both are guaranteed not to collect any non-garbage actors (safety) and to eventually collect all garbage actors (liveness).
Publisher's Version Article Search
Attached and Detached Closures in Actors
Elias Castegren, Dave Clarke, Kiko Fernandez-Reyes, Tobias Wrigstad, and Albert Mingkun Yang
(KTH, Sweden; Uppsala University, Sweden)
Expressive actor models combine aspects of functional programming into the pure actor model enriched with futures. Such functional features include first-class closures which can be passed between actors and chained on futures. Combined with mutable objects, this opens the door to race conditions. In some situations, closures may not be evaluated by the actor that created them yet may access fields or objects owned by that actor. In other situations, closures may be safely fired off to run as a separate task. This paper discusses the problem of who can safely evaluate a closure to avoid race conditions, and presents the current solution to the problem adopted by the Encore language. The solution integrates with Encore's capability type system, which influences whether a closure is attached and must be evaluated by the creating actor, or whether it can be detached and evaluated independently of its creator. Encore's current solution to this problem is not final or optimal. We conclude by discussing a number of open problems related to dealing with closures in the actor model.
Publisher's Version Article Search

Agents

A Scripting Language for Practical Agent-Oriented Programming
Federico Bergenti, Stefania Monica, and Giuseppe Petrosino
(University of Parma, Italy)
This paper describes the features of a scripting language proposed to support the practical implementation of agents and multi-agent systems using an agent-oriented programming approach. Agents are programmed in terms of procedures to be executed when interesting events occur, and the language provides specific constructs to describe managed events and related procedures. Among possible events, those related to communication are supported by specific constructs because of their relevance for the implementation of multi-agent systems. The proposed language is characterised by a strongly expressive syntax largely inspired by modern scripting languages to promote readability and to make agent programs similar to pseudocodes. Such a feature ensures that the programmer can use the language to describe the reactions of agents to events at a high level of abstraction, with all the advantages that it brings in terms of software quality.
Publisher's Version Article Search

proc time: 5.27