Original software publicationAnemone: A workbench for the Multi-Bach coordination language
Introduction
In order to ease the development of interactive and distributed systems, Gelernter and Carriero have advocated in [1] to clearly separate the interactional and the computational aspects of software components. Their claim has been supported by the design of a model, Linda [2], originally presented as a set of inter-agent communication primitives which may be added to almost any programming language. Besides process creation, this set includes primitives for adding, deleting, and testing the presence/absence of data in a shared dataspace.
A number of other models, now referred to as coordination models, have been proposed afterwards (see e.g. [3], [4], [5], [6], [7], [8], [9], [10]). However, although many pieces of work have been devoted to the proposal of new languages, semantics and implementations, just a few articles (e.g. [11], [12], [13], [14]) have addressed the concerns of constructing programs in coordination languages in practice, in particular in checking that what is described by programs actually corresponds to what has to be modeled. This article aims at addressing this need by introducing a workbench, named Anemone, to reason over Linda-like languages. More specifically, our goal is threefold:
- •
to allow the user to understand the meaning of instructions written in Linda-like languages, by showing how they can be executed step by step and how the contents of the shared space, central to coordination languages, can be modified so as to release suspended processes;
- •
to allow the user to better grasp the modeling of real-life systems, by connecting agents to animations representing the evolution of the modeled system;
- •
to allow the user to check properties by model checking reachability formulae and by producing traces that can be replayed as evidences of the establishment of the formulae.
- •
the tool should be simple to deploy and to use. As a result, we have built it as a standalone executable file. We also propose a process algebra, named Multi-Bach,1 that allows the user to concentrate on the key coordination and animation features and consequently avoid the burden of handling other features such as those induced by the integration of the code in a host language;
- •
the tool should maintain a direct relation between what is written by the user and its internal representation. This property allows the user to better grasp what is actually computed as well as to produce meaningful traces.
To make the paper more concrete, we use the Anemone workbench on a running example, the rush hour puzzle. This game consists in moving cars and trucks on a grid, according to their direction, such that a specific car, the red car, can exit. It can be formulated as a coordination problem by considering cars and trucks as autonomous agents which have to coordinate on the basis of free places.
This work builds upon previous work by the authors on coordination languages, in particular on [15], [16], [17], [18], [19], [20], [21], [22], [23], [24], [25]. In these pieces of work, a Linda-like dialect has been proposed under the name of Bach. It is enriched in this paper by primitives necessary to model and animate systems.
This article is also an extension of a preliminary work [26] presented at the Coordination'19 conference. Although the research goals are the same, several features have been revised and new ones have been included, notably as regards the process algebra, the description of scenes, and facilities provided by the workbench. The resulting workbench is available at https://github.com/UNamurCSFaculty/anemone together with examples, videos, tutorial, documentation as well as an extended version of this article.
The rest of this paper is organized as follows. Section 2 describes the main functionalities of Anemone and, in doing so, provides an overview of the workbench. Section 3 specifies the coordination language and temporal logic to be used in the workbench. Section 4 compares our work with related work. Finally, Section 5 draws our conclusion and suggests future work.
Section snippets
The Anemone workbench in a snapshot
Following Linda, the Multi-Bach language relies on a shared space to coordinate processes. It is this space that provides the decoupling of time and space of processes which is central to so-called data-based coordination languages [27]. As a natural consequence, Anemone is articulated around a so-called interactive blackboard. As depicted in Fig. 1, it starts by displaying the current contents of the shared space and allows to interact directly through the tell, get, filter, unfilter and clear
Definition of data
Following Linda, the Bach language [20], [28] uses four primitives for manipulating pieces of information: to put a piece of information on a shared space, ask to check its presence, to check its absence and get to check its presence and remove one occurrence. In its simplest version, named BachT, pieces of information consist of atomic tokens and the shared space, called the store, amounts to a multiset of tokens. Although in principle sufficient to code many applications, this is
Related work
The Extensible Coordination Tools [11] (ECT) consist of a set of plug-ins for the Eclipse platform that provide graphical editing facilities of Reo connectors, the animation of these connectors as well as model checking based on constraint automata or a translation to the process algebra mCRL2 [32]. Related to ECT is a tool proposed in [33] that creates animations for Reo connectors by using on-the-fly generated Flash code. Although it is certainly less elaborated, our work differs in several
Conclusion
The article has introduced a workbench for reasoning over a Linda-like coordination language at three levels: (i) by executing instructions in a step by step or automatic manner while showing their impact on the shared space, (ii) by illustrating computations by animations and (iii) by model checking properties by means of temporal formulae.
The current version has been designed to be as simple as possible yet incorporating key ideas. As a result, it can be improved in many aspects, in
CRediT authorship contribution statement
Jean-Marie Jacquet: Conceptualization, Methodology, Software, Supervision, Writing – original draft, Writing – review & editing. Manel Barkallah: Software, Writing – review & editing.
Declaration of Competing Interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
References (51)
- et al.
AErlang: empowering Erlang with attribute-based communication
Sci. Comput. Program.
(2018) - et al.
On the expressiveness of coordination via shared dataspaces
Sci. Comput. Program.
(2003) - et al.
On the introduction of density in tuple-space coordination languages
Sci. Comput. Program.
(2016) - et al.
Fully abstract models and refinements as tools to compare agents in timed coordination languages
Theor. Comput. Sci.
(2009) - et al.
On the expressiveness of timed coordination via shared dataspaces
Electron. Notes Theor. Comput. Sci.
(2007) - et al.
On the expressiveness of relative-timed coordination models
Electron. Notes Theor. Comput. Sci.
(2004) - et al.
Blackboard rules: from a declarative reading to its application for coordinating context-aware applications in mobile ad hoc networks
Sci. Comput. Program.
(2016) Temporal and modal logic
Results on the propositional mu-calculus
Theor. Comput. Sci.
(1983)- et al.
Coordination languages and their significance
Commun. ACM
(1992)
Linda in context
Commun. ACM
SONIA: an adaptation of LINDA for coordination of activities in organisations
μ2 Log: towards remote coordination
Coordination in context: authentication, authorisation and topology in mobile agent applications
A lightweight coordination middleware for mobile computing
Coordinating services in open distributed systems with LAURA
The Klaim project: theory and practice
LIME: a coordination model and middleware supporting mobility of hosts and agents
ACM Trans. Softw. Eng. Methodol.
Formal design and verification of long-running transactions with Extensible Coordination Tools
IEEE Trans. Serv. Comput.
ReoLive: analysing connectors in your browser
TAPAs: a tool for the analysis of process algebras
X-Klaim is back
On the expressiveness of Linda-like concurrent languages
Electron. Notes Theor. Comput. Sci.
On density in coordination languages
On distributed density in tuple-based coordination languages
Cited by (2)
On the Introduction of Guarded Lists in Bach: Expressiveness, Correctness, and Efficiency Issues
2023, Electronic Proceedings in Theoretical Computer Science, EPTCS