In recent years, companies have increasingly invested in Industry 4.0 research to automate repetitive tasks or activities that may be harmful to humans. For instance, large-scale warehouses, such as those operated by Amazon, rely heavily on mobile robots to streamline logistics operations and ensure worker safety. At the same time, robot manufacturers are releasing more reliable platforms with advanced capabilities, making them suitable for complex industrial tasks. Despite this growing interest and technological progress, significant challenges remain. A key and non-trivial issue lies in the integration of heterogeneous robot fleets: each vendor typically employs proprietary technologies and interfaces, which hinders interoperability and limits the potential of multi-brand deployments.In this work, we introduce HarmoniKt, an extensible middle-ware that addresses this challenge by introducing an abstraction layer and providing a unified REST API for the control and management of heterogeneous robots. Our solution has been validated in a physical industrial-like environment using a mixed fleet of Boston Dynamics Spot and Mobile Industrial Robots (MiR). Furthermore, we present a comparative analysis showing that the access latency introduced by our middleware is not significantly higher than that of direct robot access, demonstrating the feasibility of unified robot management without compromising performance.

Multi-agent systems are designed to deal with open, distributed systems with unpredictable dynamics, which makes them inherently hard to test. The value of using simulation for this purpose is recognized in the literature, although achieving sufficient fidelity (i.e., the degree of similarity between the simulation and the real-world system) remains a challenging task. This is exacerbated when dealing with cognitive agent models, such as the Belief Desire Intention (BDI) model, where the agent codebase is not suitable to run unchanged in simulation environments, thus increasing the reality gap between the deployed and simulated systems. We argue that BDI developers should be able to test in simulation the same specification that will be later deployed, with no surrogate representations. Thus, in this paper, we discuss how the control flow of BDI agents can be mapped onto a Discrete Event Simulation (DES), showing that such integration is possible at different degrees of granularity. We substantiate our claims by producing an open-source prototype integration between two pre-existing tools (JaKtA and Alchemist), showing that it is possible to produce a simulation-based testing environment for distributed BDI agents, and that different granularities in mapping BDI agents over DESs may lead to different degrees of fidelity.

Abstract Driven by the rising interest in machine learning techniques, mathematical continuous optimization algorithms have made great progress. Among them, first-order optimization algorithms, which rely on the first derivative (gradient) to find a function’s minimum or maximum, have gained popularity due to their efficiency and scalability. As a result, a vast number of optimization algorithms have been developed, each applying different techniques and offering diverse guarantees. This variety, while beneficial, makes selecting the most appropriate algorithm a challenging yet crucial task–choosing the wrong one may lead to sub-par accuracy or performance. This paper explores the state of the art in continuous first-order optimization algorithms, offering guidance for selecting the most suitable method. We classify 23 algorithms, detailing their dependency relationships, theoretical foundations, and optimization strategies. The analysis includes a performance evaluation using implementations in the PyTorch framework. Convergence, quantified by the area under the training-loss curve, is assessed with two benchmarks: the Rosenbrock function as a standard test and ResNet-18 training on the CIFAR-10 dataset as a practical test. We evaluate performance using an integral metric and analyze robustness to hyperparameter variations, including learning rate sensitivity. Additionally, we introduce a classification of algorithm convergence behaviors. These experiments provide insights into algorithm performance across varying problem complexities and highlight their stability under hyperparameter changes. Practitioners and researchers can use this work as a guide to identify the set of most likely good candidates as first-order optimization algorithms for their use case.

Today’s distributed and pervasive computing addresses large-scale cyber-physical ecosystems, characterised by dense and large networks of devices capable of computation, communication and interaction with the environment and people. While most research focuses on treating these systems as ‘composites’ (i.e., heterogeneous functional complexes), recent developments in fields such as self-organising systems and swarm robotics have opened up a complementary perspective: treating systems as ‘collectives’ (i.e., uniform, collaborative and self-organising groups of entities). This article explores the motivations, state of the art and implications of this ‘collective computing paradigm’ in software engineering. In particular, it discusses its peculiar challenges, implied by characteristics like distribution, situatedness, large scale and cooperative nature. These challenges outline significant directions for future research in software engineering, touching on aspects such as macro-programming, collective intelligence, self-adaptive middleware, learning/synthesis of collective behaviour, human involvement, safety and security in collective cyber-physical ecosystems.

Recent advancements in multi-agent reinforcement learning led to systems in which large groups of agents work together to learn shared policies and achieve collective behavior. This approach is increasingly important for many applications, including swarm robotics, crowd sensing, and large-scale IoT networks. In fact, these systems require repeated experimentation to learn from experience: simulation becomes thus essential, as deploying and testing in real-world environments incurs in high costs and practical challenges. In response to this need, our paper introduces a simulation-based pipeline to gather the necessary experience for many-agent learning. We highlight the requirements of such pipeline and the role of simulation, presenting also a practical prototype implemented in Alchemist, a simulator designed for very large-scale systems. This pipeline provides a scalable, modular, and flexible environment for developing and testing many-agent reinforcement learning strategies.

Designing and testing distributed systems can be a daunting task, especially when the system is composed of heterogeneous devices, it is expected to be robust to disruptions, and is meant to scale to a large number of nodes. In practice, this mandates the use of simulations to verify the system during development. Additionally, disruptions and disturbance patterns are hardly predictable, and the system’s behavior must thus be subject to test under widely varying conditions, typically implying a stochastic process and multiple simulation runs to assess whether the system meets its functional requirements. Often, running multiple simulations while a system is being developed is time- and resource-consuming, as results are visible and aggregated at termination, especially in cases in which simulations are distributed across multiple devices to speed up the computation. In this paper, we discuss a potential solution to monitor multiple distributed simulations, querying data efficiently while they progress, in order to provide early feedback to the developers. We present a general architecture for the system, discuss the technological opportunities and challenges, and provide a functional open-source prototype implementation based on a simulator used for several scientific exemplaries in the last decade.

The capability to accurately simulate the behavior of a racing car is paramount in modern-day racing competitions to quickly find a good base setup to kick-start the work on track. Typically, a professional driver is employed to drive the simulated race car and provide feedback. However, this operation is expensive and time-consuming, as capable human drivers quickly become a bottleneck. In conjunction with highly accurate simulations of the physical car’s behavior, a capable virtual driver could thus accelerate the car setup and development to a great extent. In this paper, we propose to apply a data-driven predictive control approach called Data-enabled Predictive Control to model a racing driver by tracking a pre-defined trajectory. We compare our proposed approach with an industrial first-choice Proportional-Integral-Derivative controller and state-of-the-art Model Predictive Control controller, finding that the approach is feasible, and it can provide significant improvements over the state-of-the-art, especially for trajectories whose feasibility is at the edge of the car’s capabilities.

In recent years, the infrastructure supporting the execution of situated distributed computations evolved at a fast pace. Modern collective adaptive applications – as found in the Internet of Things, swarm robotics, and social computing – are designed to be executed on very diverse devices and to be deployed on infrastructures composed of devices ranging from cloud servers to wearable devices, constituting together a cloud–edge continuum. The availability of such an infrastructure opens to better resource utilisation and performance but, at the same time, introduces new challenges to software designers, as applications must be conceived to be able to adapt to changing deployment domains and conditions. In this paper, we introduce a practical framework for the development of systems based on the concept of pulverisation, meant to neatly separate business logic and deployment concerns, allowing applications to be defined independently of the infrastructure they will execute upon, thus supporting scalability. The framework is based on a domain-specific language capturing, in a declarative fashion: pulverised application components, device capabilities, resource allocation, and (runtime re-) configuration policies. The framework, implemented in Kotlin multiplatform and available as open source, is then evaluated in a small-scale real-world demo and in a city-scale simulated scenario, demonstrating the feasibility of the approach and its potential benefits in achieving better trade-offs between performance and resource utilisation.

A recurrent task in coordinated systems is managing (estimating, predicting, or controlling) signals that vary in space, such as distributed sensed data or computation outcomes. Especially in large-scale settings, the problem can be addressed through decentralised and situated computing systems: nodes can locally sense, process, and act upon signals, and coordinate with neighbours to implement collective strategies. Accordingly, in this work we devise distributed coordination strategies for the estimation of a spatial phenomenon through collaborative adaptive sampling. Our design is based on the idea of dynamically partitioning space into regions that compete and grow/shrink to provide accurate aggregate sampling. Such regions hence define a sort of virtualised space that is "fluid", since its structure adapts in response to pressure forces exerted by the underlying phenomenon. We provide an adaptive sampling algorithm in the field-based coordination framework, and prove it is self-stabilising and locally optimal. Finally, we verify by simulation that the proposed algorithm effectively carries out a spatially adaptive sampling while maintaining a tuneable trade-off between accuracy and efficiency.

No abstract available.

Research trends are pushing artificial intelligence (AI) across the Internet of Things (IoT)–edge–fog–cloud continuum to enable effective data analytics, decision making, as well as the efficient use of resources for QoS targets. Approaches for collective adaptive systems (CASs) engineering, such as aggregate computing, provide declarative programming models and tools for dealing with the uncertainty and the complexity that may arise from scale, heterogeneity, and dynamicity. Crucially, aggregate computing architecture allows for “pulverization”: applications can be decomposed into many deployable micromodules that can be spread across the ICT infrastructure, thus allowing multiple potential deployment configurations for the same application logic. This article studies the deployment architecture of aggregate-based edge services and its implications in terms of performance and cost. The goal is to provide methodological guidelines and a model-based toolchain for the generation and simulation-based evaluation of potential deployments. First, we address this subject methodologically by proposing an approach based on deployment code generators and a simulation phase whose obtained solutions are assessed with respect to their performance and costs. We then tailor this approach to aggregate computing applications deployed onto an IoT–edge–fog–cloud infrastructure, and we develop a corresponding toolchain based on Protelis and EdgeCloudSim. Finally, we evaluate the approach and tools through a case study of edge multimedia streaming, where the edge ecosystem exhibits intelligence by self-organizing into clusters to promote load balancing in large-scale dynamic settings.

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.

Recent trends in software production fostered the adoption of microservice architectures, where a product is the result of the coordinated execution of several loosely coupled autonomous services, thus promoting modularity, scalability, and integration of legacy products by wrapping. This architectural style also promotes parallel development, as different teams can be in charge of different services; however, this parallelization is at first sight at odds with the established practice of continuous integration: a change to a single service may cause cascading effects that the local testing cannot capture, and the overall functionality may thus get compromised even though all services apparently work. In this paper, we report an experience of a successful and thorough implementation of DevOps techniques into a large business, carried out by a relatively small team. We discuss the steps taken to build a continuous integration pipeline performing system-wide quality assurance, the development practices that enable such a pipeline to be effective, and the lessons learned by applying these practices in a digital publishing industry setting.

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 "space and time" of distributed data structures called fields. More specifically regarding time, in field-based coordination (as in many other distributed approaches to coordination) it is assumed that local activities in each device are regulated by a fair and unsynchronised fixed clock working at the platform level. In this work, we challenge this assumption, and propose an alternative approach where scheduling is programmed in a natural way (along with usual field-based coordination) in terms of causality fields, each enacting a programmable distributed notion of a computation "cause" (why and when a field computation has to be locally computed) and how it should change across time and space. Starting from low-level platform triggers, such causality fields can be organised into multiple layers, up to high-level, collectively-computed time abstractions, to be used at the application level. This reinterpretation of time in terms of articulated causality relations allows us to express what we call "time-fluid" coordination, where scheduling can be finely tuned so as to select the triggers to react to, generally allowing to adaptively balance performance (system reactivity) and cost (resource usage) of computations. We formalise the proposed scheduling framework for field-based coordination in the context of the field calculus, discuss an implementation in the aggregate computing framework, and finally evaluate the approach via simulation on several case studies.

The complexity of large-scale distributed systems, particularly when deployed in physical space, calls for new mechanisms to address composability and reusability of collective adaptive behaviour. Computational fields have been proposed as an effective abstraction to fill the gap between the macro-level of such systems (specifying a system’s collective behaviour) and the micro-level (individual devices’ actions of computation and interaction to implement that collective specification), thereby providing a basis to better facilitate the engineering of collective APIs and complex systems at higher levels of abstraction. This article proposes a full formal foundation for field computations, in terms of a core (higher-order) calculus of computational fields containing a few key syntactic constructs, and equipped with typing, denotational and operational semantics. Critically, this allows formal establishment of a link between the micro- and macro-levels of collective adaptive systems by a result of computational adequacy and abstraction for the (aggregate) denotational semantics with respect to the (per-device) operational semantics.

Abstract We introduce Spatial Tuples, an extension of the basic tuple‐based model for distributed multi‐agent system coordination where (a) tuples are conceptually placed in regions of the physical world and possibly move anchored to a mobile computational device, (b) the behaviour of standard Linda coordination primitives is extended so as to depend on the spatial properties of the coordinating agents, tuples, and the topology of space, and (c) the tuple space can be conceived as a virtual layer augmenting physical reality. Motivated by the needs of mobile augmented‐reality applications, Spatial Tuples explicitly aims at supporting space‐aware and space‐based coordination in agent‐based pervasive computing scenarios. This paper presents the coordination model, its formalization as a process algebra, a library of patterns of coordination it enables, and a discussion of application scenarios, challenges, and open issues for future works.

A key problem when coordinating the behaviour of spatially situated networks, like those typically found in the Internet of Things (IoT), is adaptation to changes impacting network topology, density, and heterogeneity. Computational goals for such systems, however, are often dependent on geometric properties of the continuous environment in which the devices are situated rather than the particulars of how devices happen to be distributed through it. In this article, we identify a new property of distributed algorithms, eventual consistency , which guarantees that computation converges to a final state that approximates a predictable limit, based on the continuous environment, as the density and speed of devices increases. We then identify a large class of programs that are eventually consistent, building on prior results on the field calculus computational model (Beal et al. 2015; Viroli et al. 2015a) that identify a class of self-stabilizing programs. Finally, we confirm through simulation of IoT application scenarios that eventually consistent programs from this class can provide resilient behavior where programs that are only converging fail badly.

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.