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

11th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control (AGERE 2021), October 17, 2021, Chicago, IL, USA

AGERE 2021 – Preliminary Table of Contents

Contents - Abstracts - Authors

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

Frontmatter

Title Page


Welcome from the Chairs
Welcome to the proceedings of the 11th International Workshop on Programming based on Actors, Agents, and Decentralized Control (AGERE!), co-located in Chicago and online with SPLASH 2021. 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.

Papers

Contract-Based Return-Value Commutativity: Safely Exploiting Contract-Based Commutativity for Faster Serializable Transactions
Tim Soethout ORCID logo, Tijs van der Storm, and Jurgen J. Vinju ORCID logo
(ING Bank, Netherlands; CWI, Netherlands; RUG, Netherlands; TUE, Netherlands)
A key challenge of designing distributed software systems is maintaining data consistency. We can define data consistency and data isolation guarantees –e.g. serializability– in terms of schedules of atomic reads and writes, but this excludes schedules that would be semantically consistent. Others use manually provided information on “non-conflicting operations” to define guarantees that work for more applications allowing more parallel schedules. To be safe, an engineer might avoid marking operations as non-conflicting, with detrimental effects to efficiency. To be fast, they might mark more non-conflicting operations than is strictly safe.
Our goal is to help engineers by automatically deriving commutative operations (using their respective contracts) such that more parallel schedules with global consistency are possible. We define a new general consistency and isolation guarantee named “Return-Value Serializability” to check consistency claims automatically, and we present distributed event processing algorithms that make use of the same “Contract-based Commutativity” information. We validated both the definitions and the algorithms using model-checking with /. Previous work provided evidence that local coordination avoidance such as applied here has a significant positive effect on the performance of distributed transaction systems.
Client-centric return-value commutativity promises to hit a sweet spot in design trade-offs for business applications, such as payment systems, that must scale-out while their operations are not embarrassingly parallel and consistency guarantees are of the highest priority. It can also provide design feedback, indicating that some operations will simply not scale together even before a line of code has been written.

Article Search Artifacts Available
Session Types in Elixir
Gerard Tabone ORCID logo and Adrian Francalanza ORCID logo
(University of Malta, Malta)
This paper proposes an adaptation of session types to provide behavioural information about public functions in Elixir modules. We formalise typechecking rules for the main constructs of the language. This allows us to statically determine whether a function implementation observes its session endpoint specification. Based on this type system, we then construct a tool that automates typechecking for Elixir modules.

Article Search
What’s the Problem? Interrogating Actors to Identify the Root Cause of Concurrency Bugs
Carmen Torres Lopez ORCID logo, Louise Van Verre, and Elisa Gonzalez Boix ORCID logo
(Vrije Universiteit Brussel, Belgium)
Programs written using Communicating Event-Loops (CEL) concurrency model do not suffer from low-level data races by design but are not exempt from other concurrency bugs, such as behavioral deadlocks and message order violations.
When programmers need to find the root cause of a bug, they typically ask questions about the application's behavior. However, current debugging tools are mostly operational, offering features at the source code level like breakpoints and watchpoints. Consequently, understanding the program behavior when debugging can take a lot of time for developers since questions on behaviors need to be mapped into operations in the debugger.
Inspired by interrogative debugging, this paper proposes an interactive debugging approach for actor-based programs that enable developers to reason about the program output by selecting questions from a set of predefined questions about the code and the program's execution. We present the design of the questions and answers, and we describe a prototype implementation in Apgar, an online debugger for actor-based programs written in SOMns. We define questions based on key concepts of the actor model: actors, turns, messages, and promises. The debugger then computes the answers by analyzing a recorded trace of events about the program execution.

Article Search

proc time: 1.24