Original software publication
Anemone: A workbench for the Multi-Bach coordination language

https://doi.org/10.1016/j.scico.2020.102579Get rights and content

Highlights

  • Programming environments are required to analyze and reason on coordination programs.

  • Animations help to understand the modeling of concrete systems.

  • Multi-Bach is a process algebra well-suited to describe concurrent systems.

Abstract

Although many research efforts have been spent on the theory and implementation of data-based coordination languages, not much effort has been devoted to constructing programming environments to analyze and reason over programs written in these languages. This paper proposes a workbench for describing concurrent systems using a Linda-like language, for animating them and for reasoning over them using a reachability logic.

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.

In building the workbench, we also aim at two main properties:
  • 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 6×6 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: tell to put a piece of information on a shared space, ask to check its presence, nask 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)

  • N. Carriero et al.

    Linda in context

    Commun. ACM

    (1989)
  • M. Banville

    SONIA: an adaptation of LINDA for coordination of activities in organisations

  • K.D. Bosschere et al.

    μ2 Log: towards remote coordination

  • M. Cremonini et al.

    Coordination in context: authentication, authorisation and topology in mobile agent applications

  • C.-L. Fok et al.

    A lightweight coordination middleware for mobile computing

  • R. Tolksdorf

    Coordinating services in open distributed systems with LAURA

  • L. Bettini et al.

    The Klaim project: theory and practice

  • A. Murphy et al.

    LIME: a coordination model and middleware supporting mobility of hosts and agents

    ACM Trans. Softw. Eng. Methodol.

    (2006)
  • N. Kokash et al.

    Formal design and verification of long-running transactions with Extensible Coordination Tools

    IEEE Trans. Serv. Comput.

    (2013)
  • R. Cruz et al.

    ReoLive: analysing connectors in your browser

  • F. Calzolai et al.

    TAPAs: a tool for the analysis of process algebras

  • L. Bettini et al.

    X-Klaim is back

  • A. Brogi et al.

    On the expressiveness of Linda-like concurrent languages

    Electron. Notes Theor. Comput. Sci.

    (1998)
  • D. Darquennes et al.

    On density in coordination languages

  • D. Darquennes et al.

    On distributed density in tuple-based coordination languages

  • View full text