(note: picture from 2014, I may look older now)

Danilo Pianini

• Associate Professor @ University of Bologna
• Department of Computer Science and Engineering (DISI), Cesena, Italy

Research:

• about 100 publications in peer-reviewed venues
• Head of the Pervasive Software Lab

Institutional roles:

• Department Delegate for Open Science
• FAIR Champion of UniBo

Teaching:

• Object-Oriented Programming (Bachelor)
• Software Design and Development (Bachelor)
• Software Process Engineering (Master)
• Micro-macro Computational Models: Theory, Applications, and Emergent Properties (Collegio Superiore)

Context:

• large-scale systems made of many heterogeneous devices
• devices interact locally
  • central coordination impossible, undesirable, or available only intermittently
• global behavior emerges from local interactions
  • classically, inspired by natural systems (e.g., social insects)
• the system must be:
  • robust to failures (including unknown unknowns)
  • adaptive to changing environments
  • scalable to large numbers of devices

Main open questions:

• how do we test/verify such systems?
• how do we engineer emergence?
• how do we deal with openness and unpredictability?

• First working period abroad

• Agent-based approaches: design simple agents that interact locally to produce global behaviors

• Ant-colony-inspired approach to move similar files closer together in a distributed storage system

• Validated by run on multiple systems (nine PCs)

• First publication: Self Organization in Coordination Systems Using a WordNet-Based Ontology, SASO 2010

• where is “large scale”?

• portability of the approach?

• We need simulation to test in large scale

• Agent-based, time-driven simulators scale to ~10² agents before becoming effectively unusable

• Idea: pick a high-performance engine from stochastic chemistry, and extend the model to spatially distributed systems

  • Risk: extensions destroy performance
  • Result: not as fast as pure chemistry, but it can still simulate ~10³-10⁴ agents efficiently

• First journal publication: Chemical-oriented simulation of computational systems with ALCHEMIST

• how to reflect changes in the environment within the digital world?

• how to simulate richer environments?

• SAPERE: Self-aware Pervasive Service Ecosystems

  • PI: Franco Zambonelli (Università di Modena e Reggio Emilia)
  • EU FP7 project (2010-2013)

• Idea:

  • devices and network are reified as “live sematic annotations” (LSAs) in a shared space
  • LSAs combine by means of “eco-laws” to produce emergent behaviors

• Somewhat a predecessor of the “digital twin” concept

• Minimal changes to the desired algorithms require a complete redesign of the eco-laws

  • No modularity
  • Limited reusability

• First doctoral period abroad

• Alchemist became capable of simulating the SAPERE model and more:

  • Biological systems (e.g., A model for drosophila melanogaster development from a single cell to stripe pattern formation)
  • Smart cities (e.g., HPC from a self-organisation perspective: The case of crowd steering at the urban scale)
  • Execution on High-Performance Computing Clusters (e.g., Distributed statistical analysis of complex systems modeled through a chemical metaphor)

• The simulator is ready for complex, large-scale experiments

• The open question remains:

  • How do we design self-organizing software top down, modularly?

• Amorphous computing (Programming an Amorphous Computational Medium) introduced the idea of programming millions of devices as a single computational unit, and programming them via global-to-local compilation.
• $\Rightarrow$ MIT Proto implemented this idea, but its semantics was complex and formalized only ex- post.
• $\Rightarrow$ The Field Calculus was a simplified formal model designed to capture the essence of such systems.
• $\Rightarrow$ From the Field Calculus, we designed Protelis, the first Higher-Order, practical aggregate programming language.
• $\Rightarrow$ From Protelis, we derived the Higher Order Field Calculus (HOFC).
• $\Rightarrow$ The HOFC became the theoretical foundation of Aggregate Computing.

• Compute by means of computational fields:
  • A computational field is a mapping from devices to values
  • Computational fields can be combined, transformed, and manipulated as first-class values
• The perception is that of a single computational device operating on fields
  • Each device runs the same program
  • Each device can sense the surrounding values of fields
  • Each device contributes its own value to the fields
• Round based execution model, each device repeatedly:
  1. gathers neighbor values and senses local context
  2. computes the program
  3. shares the result with neighbors
• (functional) Language-based approach:
  • The programmer writes programs in a dedicated language (e.g., Protelis)
  • Programs are compiled to local code for each device
  • The distributed execution produces the desired global behavior
  • Reuse and modularity are built-in!
    • a library of proven self-stabilizing building blocks is available
    • composition of building blocks is guaranteed to preserve self-stabilization

• Swarm Robotics
  • A Demonstrator for Self-organizing Robot Teams
  • MacroSwarm: A scala framework for swarm programming
  • A Field-Based Approach for Runtime Replanning in Swarm Robotics Missions
• Communication in navigation systems
  • Robust Communication Through Collective Adaptive Relay Schemes for Maritime Vessels
• Federated Learning
  • Decentralized proximity-aware clustering for collective self-federated learning
• “Pulverization” of deployed components
  • Scalability through Pulverisation: Declarative deployment reconfiguration at runtime
  • Dynamic IoT deployment reconfiguration: A global-level self-organisation approach
• Bio-inspired construction
  • An Aggregate Vascular Morphogenesis Controller for Engineered Self-Organising Spatial Structures
• Multi-drone tracking
  • Decentralized Multi-Drone Coordination for Wildlife Video Acquisition

Technology transfer: Project Wood4.0 - Partner: SCM Group

• Automated, self-healing update system for large-scale wood processing manufacturing machines
  • (patent pending)

Advanced Tooling

Collektive: Aggregate Programming in pure Kotlin

JaKtA: type-safe Belief-Desire-Intention agent-oriented programming

Emerge: affordable swarm robotics