Time-fluid field-based coordination

Emerging application scenarios, such as cyber-physical systems (CPSs), the Internet of Things (IoT), and edge computing, call for coordination approaches addressing openness, self-adaptation, heterogeneity, and deployment agnosticism. Field-based coordination is one such approach, promoting the idea of programming system coordination declaratively from a global perspective, in terms of functional manipulation and evolution in \u201cspace and time\u201d of distributed data structures, called fields. More specifically, regarding time, in field-based coordination it is assumed that local activities in each device, called computational rounds, are regulated by a fixed clock, typically, a fair and unsynchronized distributed scheduler. In this work, we challenge this assumption, and propose an alternative approach where the round execution scheduling is naturally programmed along with the usual coordination specification, namely, in terms of a field of causal relations dictating what is the notion of causality (why and when a round has to be locally scheduled) and how it should change across time and space. This abstraction over the traditional view on global time allows us to express what we call \u201ctime-fluid\u201d coordination, where causality can be finely tuned to select the event triggers to react to, up to to achieve improved balance between performance (system reactivity) and cost (usage of computational resources). We propose an implementation in the aggregate computing framework, and evaluate via simulation on a case study

A Collective Adaptive Approach to Decentralised k-Coverage in Multi-robot Systems

We focus on the online multi-object k-coverage problem (OMOkC), where mobile robots are required to sense a mobile target from k diverse points of view, coordinating themselves in a scalable and possibly decentralised way. There is active research on OMOkC, particularly in the design of decentralised algorithms for solving it. We propose a new take on the issue: Rather than classically developing new algorithms, we apply a macro-level paradigm, called aggregate computing, specifically designed to directly program the global behaviour of a whole ensemble of devices at once. To understand the potential of the application of aggregate computing to OMOkC, we extend the Alchemist simulator (supporting aggregate computing natively) with a novel toolchain component supporting the simulation of mobile robots. This way, we build a software engineering toolchain comprising language and simulation tooling for addressing OMOkC. Finally, we exercise our approach and related toolchain by introducing new algorithms for OMOkC; we show that they can be expressed concisely, reuse existing software components and perform better than the current state-of-the-art in terms of coverage over time and number of objects covered overall

Una piattaforma client-server universale per Aggregate Computing

L'aggregate computing è un approccio emergente utilizzato per progettare sistemi di coordinazione complessi edistribuiti. Il tutto si basa sul Field Calculus, un modello di programmazione universale utile per specificare computazioni aggregate tramite composizione di comportamenti. Tra i linguaggi ed i framework sviluppati figurano Protelis e Scafi, i quali, utilizzando approcci diversi tra di loro, forniscono implementazioni concrete del Field Calculus, permettendo di definire programmi aggregati e di mandarli in esecuzione. Avendo a disposizione diversi framework per specificare le computazioni da svolgere, si è rivelato necessario avere una piattaforma sulla quale poter eseguire tali programmi. La tesi verte sulla progettazione e conseguente implementazione di un sistema basatosu architettura client-server che permetta l’esecuzione di programmi aggregati su unarete logica di dispositivi. È prevista la possibilità di utilizzare dispositivi virtualizzati e/o reali per formare la rete che eseguirà il programma. È prevista anche la possibilità per un client dientrare in modalità “lightweight”, nella quale non sarà più quest’ultimo ad eseguire, ma sarà il server a farsi carico della sua parte, indicando al client solamente i risultati delle computazioni. Indipendentemente dalla modalità di esecuzione, il sistema è nativamente compatibile con Scafi e Protelis ed è aperto a nuove implementazioni, permettendo quindi l’esecuzione di programmi aggregati indipendentemente dal linguaggio o framework utilizzato per definirli ed eseguirli. L’intero progetto è stato sviluppato adottando una metodologia test-driven. La compatibilità del sistema con Scafi e Protelis è stata verificata testandolo con alcuni programmi di esempio forniti dagli autori dei framework stessi. Tutti i test sono stati continuamente verificati attuando un processo di continuous integration, permettendo così di individuare facilmente eventuali problematiche durante lo sviluppo

Revisione e refactoring dell'interfaccia utente del simulatore Alchemist

Lo scopo di questa tesi è la revisione e il refactoring dell'interfaccia grafica del simulatore Alchemist, per offrire una migliore esperienza d'uso all'utente. L'interfaccia grafica permette la configurazione completa di una simulazione ed il suo avvio in modalità normale o batch. Per il suo sviluppo, è stata utilizzata la libreria JavaFX, che ha permesso di separare l'aspetto del programma dalla specifica comportamentale, e supporta l'Hi-DPI, che consente al simulatore di essere scalabile anche su schermi ad alta risoluzione. L'ambiente ottenuto è intuitivo, perché offre un'esperienza d'uso simile ad un IDE di sviluppo; ed è anche consistente rispetto allo stato del file system. Nel testo sono illustrati tutti i requisiti che il progetto deve soddisfare e, inoltre, sono descritte, in modo approfondito, la progettazione e l'implementazione dell'interfaccia realizzata. Il risultato ottenuto è un ambiente funzionante, che soddisfa buona parte delle specifiche richieste e che potrà essere ampliato in futuro con nuove funzionalità

Sviluppo di un front-end di simulazione per applicazioni aggregate nel framework Scafi

La tesi è articolata in sei capitoli: nel primo vengono introdotti gli studi pregressi realizzati durante il periodo di tirocinio svolto presso l'Università di Bologna, utili a comprendere l'insieme di scelte effettuate nelle altre fasi dello studio. Nel secondo capitolo viene descritta la fase di analisi del modello da realizzare, completa di elenco dei requisiti che il front-end deve rispettare, in questa fase in modo particolare, c'è stato uno scambio di informazioni costante con il prof. Mirko Viroli e il dott. Roberto Casadei nei panni dei 'committenti' nel progetto. Nel terzo capitolo si descrive la fase di progettazione architetturale, fornendo informazioni su come il software realizza quanto richiesto in fase di analisi in termini di architettura. Si descrive, quindi, la struttura generale del front-end e si spiega il perché delle varie scelte presenti in questa fase. Nel quarto capitolo vengono descritte, invece, quelle che sono le scelte di design dettagliato, in particolare si descrive com'è possibile interfacciare il front-end con il framework \class{ScaFi} e come avviare e descrivere una simulazione aggregata. Nel quinto capitolo vengono mostrate le scelte implementative per la realizzazione del software e vengono mostrati alcuni screenshot con i risultati ottenuti e, infine, nel sesto si offre una panoramica di quello che è il risultato finale mostrando la struttura dell'interfaccia grafica corredato di analisi delle performance estratte da alcune delle possibili simulazioni eseguibili sul front-en

From distributed coordination to field calculus and aggregate computing

open6siThis work has been partially supported by: EU Horizon 2020 project HyVar (www.hyvar-project .eu), GA No. 644298; ICT COST Action IC1402 ARVI (www.cost -arvi .eu); Ateneo/CSP D16D15000360005 project RunVar (runvar-project.di.unito.it).Aggregate computing is an emerging approach to the engineering of complex coordination for distributed systems, based on viewing system interactions in terms of information propagating through collectives of devices, rather than in terms of individual devices and their interaction with their peers and environment. The foundation of this approach is the distillation of a number of prior approaches, both formal and pragmatic, proposed under the umbrella of field-based coordination, and culminating into the field calculus, a universal functional programming model for the specification and composition of collective behaviours with equivalent local and aggregate semantics. This foundation has been elaborated into a layered approach to engineering coordination of complex distributed systems, building up to pragmatic applications through intermediate layers encompassing reusable libraries of program components. Furthermore, some of these components are formally shown to satisfy formal properties like self-stabilisation, which transfer to whole application services by functional composition. In this survey, we trace the development and antecedents of field calculus, review the field calculus itself and the current state of aggregate computing theory and practice, and discuss a roadmap of current research directions with implications for the development of a broad range of distributed systems.embargoed_20210910Viroli, Mirko; Beal, Jacob; Damiani, Ferruccio; Audrito, Giorgio; Casadei, Roberto; Pianini, DaniloViroli, Mirko; Beal, Jacob; Damiani, Ferruccio; Audrito, Giorgio; Casadei, Roberto; Pianini, Danil

Computation Against a Neighbour

Recent works in contexts like the Internet of Things (IoT) and large-scale Cyber-Physical Systems (CPS) propose the idea of programming distributed systems by focussing on their global behaviour across space and time. In this view, a potentially vast and heterogeneous set of devices is considered as an "aggregate" to be programmed as a whole, while abstracting away the details of individual behaviour and exchange of messages, which are expressed declaratively. One such a paradigm, known as aggregate programming, builds on computational models inspired by field-based coordination. Existing models such as the field calculus capture interaction with neighbours by a so-called "neighbouring field" (a map from neighbours to values). This requires ad-hoc mechanisms to smoothly compose with standard values, thus complicating programming and introducing clutter in aggregate programs, libraries and domain-specific languages (DSLs). To address this key issue we introduce the novel notion of "computation against a neighbour", whereby the evaluation of certain subexpressions of the aggregate program are affected by recent corresponding evaluations in neighbours. We capture this notion in the neighbours calculus (NC), a new field calculus variant which is shown to smoothly support declarative specification of interaction with neighbours, and correspondingly facilitate the embedding of field computations as internal DSLs in common general-purpose programming languages -- as exemplified by a Scala implementation, called ScaFi. This paper formalises NC, thoroughly compares it with respect to the classic field calculus, and shows its expressiveness by means of a case study in edge computing, developed in ScaFi.Comment: 50 pages, 16 figure

Simulating large-scale aggregate MASs with alchemist and scala

Recent works in the context of large-scale adaptive systems, such as those based on opportunistic IoT-based applications, promote aggregate programming, a development approach for distributed systems in which the collectivity of devices is directly targeted, instead of individual ones. This makes the resulting behaviour highly insensitive to network size, density, and topology, and as such, intrinsically robust to failures and changes to working conditions (e.g., location of computational load, communication technology, and computational infrastructure). Most specifically, we argue that aggregate programming is particularly suitable for building models and simulations of complex large-scale reactive MASs. Accordingly, in this paper we describe SCAFI (Scala Fields), a Scala-based API and DSL for aggregate programming, and its integration with the ALCHEMIST simulator, and usage scenarios in the context of smart mobility

Agents and Robots for Reliable Engineered Autonomy

This book contains the contributions of the Special Issue entitled "Agents and Robots for Reliable Engineered Autonomy". The Special Issue was based on the successful first edition of the "Workshop on Agents and Robots for reliable Engineered Autonomy" (AREA 2020), co-located with the 24th European Conference on Artificial Intelligence (ECAI 2020). The aim was to bring together researchers from autonomous agents, as well as software engineering and robotics communities, as combining knowledge from these three research areas may lead to innovative approaches that solve complex problems related to the verification and validation of autonomous robotic systems