Danilo Pianini

Aggregate Programming for the Internet of Things

Through field calculus constructs and building-block APIs, aggregate programming could help unlock the IoTs true potential by allowing complex distributed services to be specified succinctly and by enabling such services to be safely encapsulated, modulated, and composed with one another.

Chemical-oriented simulation of computational systems with ALCHEMIST

In this paper we address the engineering of complex and emerging computational systems featuring situatedness, adaptivity and self-organisation, like pervasive computing applications in which humans and devices, dipped in a very mobile environment, opportunistically interact to provide and exploit information services. We adopt a meta-model in which possibly mobile, interconnected and communicating agents work according to a set of chemical-like laws. According to this view, substantiated by recent research on pervasive computing systems, we present the Alchemist simulation framework, which retains the performance of known Stochastic Simulation Algorithms for (bio)chemistry, though it is tailored to the specific features of complex and situated computational systems.

Protelis: practical aggregate programming

The notion of a computational field has been proposed as a unifying abstraction for developing distributed systems, focusing on the computations and coordination of aggregates of devices instead of individual behavior. Prior field-based languages, however, have suffered from a number of practical limitations that have posed barriers to adoption and use. We address these limitations by introduction of Protelis, a functional language based on computational fields and embedded in Java, thereby enabling the construction of widely reusable components of aggregate systems. We demonstrate the simplicity of Protelis integration and programming through two examples: simulation of a pervasive computing scenario in the Alchemist simulator [24], and coordinated management of a network of services.

Developing pervasive multi-agent systems with nature-inspired coordination

Pervasive computing systems can be modelled effectively as populations of interacting autonomous components. The key challenge to realizing such models is in getting separately-specified and -developed sub-systems to discover and interoperate with each other in an open and extensible way, supported by appropriate middleware services. In this paper, we argue that nature-inspired coordination models offer a promising way of addressing this challenge. We first frame the various dimensions along which nature-inspired coordination models can be defined, and survey the most relevant proposals in the area. We describe the nature-inspired coordination model developed within the SAPERE project as a synthesis of existing approaches, and show how it can effectively support the multifold requirements of modern and emerging pervasive services. We conclude by identifying what we think are the open research challenges in this area, and identify some research directions that we believe are promising.

Code Mobility Meets Self-organisation: A Higher-Order Calculus of Computational Fields

Self-organisation mechanisms, in which simple local interactions result in robust collective behaviors, are a useful approach to managing the coordination of large-scale adaptive systems. Emerging pervasive application scenarios, however, pose an openness challenge for this approach, as they often require flexible and dynamic deployment of new code to the pertinent devices in the network, and safe and predictable integration of that new code into the existing system of distributed self-organisation mechanisms. We approach this problem of combining self-organisation and code mobility by extending “computational field calculus”, a universal calculus for specification of self-organising systems, with a semantics for distributed first-class functions. Practically, this allows self-organisation code to be naturally handled like any other data, e.g., dynamically constructed, compared, spread across devices, and executed in safely encapsulated distributed scopes. Programmers may thus be provided with the novel first-class abstraction of a “distributed function field”, a dynamically evolving map from a network of devices to a set of executing distributed processes.

Linda in space-time: an adaptive coordination model for mobile ad-hoc environments

We present a vision of distributed system coordination as a set of activities affecting the space-time fabric of interaction events. In the tuple space setting that we consider, coordination amounts to control of the spatial and temporal configuration of tuples spread across the network, which in turn drives the behaviour of situated agents. We therefore draw on prior work in spatial computing and distributed systems coordination, to define a new coordination language that adds to the basic Linda primitives a small set of space-time constructs for linking coordination processes with their environment. We show how this framework supports the global-level emergence of adaptive coordination policies, applying it to two example cases: crowd steering in a pervasive computing scenario and a gradient-based implementation of Linda primitives for mobile ad-hoc networks.

HPC from a self-organisation perspective: The case of crowd steering at the urban scale

HPC normally refers to the aggregation of computational capabilities in such a way that intense computations can be executed in a much shorter time than it would require on a classic end-user machine. In this paper, we propose a different point of view on such matter: focussing on situated self-organising systems, i.e. systems in which myriads of nodes deployed in a physical environment locally cooperate in order to obtain a global coherent and robust behaviour. We show how the intrinsic need of contextual information pushes towards distribution of the computation among such nodes, resembling a sort of high-performance computing system at a urban scale. We exemplify this concept by discussing an experience on designing and simulating a crowd steering application, able to provide users walking directions considering the contingencies, in this case overcrowded areas.

Distributed statistical analysis of complex systems modeled through a chemical metaphor

The chemical-inspired programming approach is an emerging paradigm for defining the behavior of densely distributed and context-aware devices (e.g., in ecosystems of displays tailored to crowd steering, or to obtain profile-based coordinated visualization). Typically, the evolution of such systems cannot be easily predicted, thus making of paramount importance the availability of techniques and tools supporting prior-to-deployment analysis. Exact analysis techniques do not scale well when the complexity of systems grows: as a consequence, approximated techniques based on simulation assumed a relevant role. This work presents a new simulation-based distributed analysis tool addressing the statistical analysis of such a kind of systems. The tool has been obtained by chaining two existing tools: MultiVeSta and Alchemist. The former is a recently proposed lightweight tool which allows to enrich existing discrete event simulators with automated and distributed statistical analysis capabilities, while the latter is an efficient simulator for chemical-inspired computational systems. The tool is validated against a crowd steering scenario, and insights on the performance are provided by discussing how the analysis tasks scale on a multi-core architecture.

Self-Adaptation to Device Distribution Changes

A key problem when coordinating the behaviour of devices in situated networks (e.g., pervasive computing, smart cities, Internet of Things, wireless sensor networks) is adaptation to changes impacting network topology, density, and heterogeneity. Computational goals for such systems are often expressed in terms of geometric properties of the continuous environment in which the devices are situated, and the results of resilient computations should depend primarily on that continuous environment, rather than the particulars of how devices happen to be distributed through it. In this paper, we identify a new property of distributed algorithms, eventual consistency, which guarantees that computation self-stabilizes to a final state that approximates a predictable limit 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 to identify a class of self-stabilizing programs. Finally, we confirm through simulation of pervasive network scenarios that eventually consistent programs from this class can provide resilient behavior where programs that are only self-stabilizing fail badly.

Improving Gossip Dynamics Through Overlapping Replicates

Gossip protocols are a fast and effective strategy for computing a wide class of aggregate functions involving coordination of large sets of nodes. The monotonic nature of gossip protocols, however, mean that they can typically only adjust their estimate in one direction unless restarted, which disrupts the values being returned. We propose to improve the dynamical performance of gossip by running multiple replicates of a gossip algorithm, overlapping in time. We find that this approach can significantly reduce the error of aggregate function estimates compared to both typical gossip implementations and tree-based estimation functions.