Software Engineering Methods for Artificial Collective Intelligence

Software Engineering Methods for
Artificial Collective Intelligence
Aggregate Computing & Beyond
Roberto Casadei, PhD
roby.casadei@unibo.it
Assistant Professor
Department of Computer Science and Engineering (DISI)
Alma Mater Studiorum – Università of Bologna
April 7, 2025
Seminar @ Gran Sasso Science Institute
https://www.slideshare.net/RobertoCasadei/
R. Casadei Intro: SE for ACI Aggregate Computing (AC) Research Highlights Wrap-up References 1/71

About myself
History: 2016 (MEng) – 2020/04 (PhD) – 2022/02 (RTD-A) – 2023/10 (RTD-B)
Research focus: software engineering for artificial collective intelligence
Main approaches: programming languages, distributed middleware, simulation
Main research thread: macro-programming / aggregate computing (see next) W
Application domains: collective adaptive systems (IoT, smart cities, robot swarms, ...)
Main communities:
∠ ACSOS (IEEE Int. Conf. on Autonomic Computing and Self-Organizing Systems)
∠ DisCoTec / COORDINATION (Int. Fed. Conf. on Distributed Computing Techniques)
∠ Others (PC): AAAI, ICCCI, SAC, ...
Participation in projects:
∠ FluidWare: A novel paradigm for Large-Scale IoT Systems (lead: Franco Zambonelli)
∠ COMMON-WEARS: COMMunity-OrieNted WEARable Computing Systems (lead: G. Fortino)
Some highlights:
∠ associate editor of Elsevier IoT, Sciendo JAISCR, Wiley CCPE
∠ IEEE TCSC Award for Excellence
IEEE TCSC Award for Excellence in
Scalable Computing (ECR)
2024 presented to
Dr. Roberto Casadei
for contributions to computational and programming paradigms supporting the
engineering of large-scale collective and self-organizing systems
IEEE Computer Society Technical Committee
on Scalable Computing (TCSC)
Professor Beniamino Di Martino, Chair for IEEE TCSC Awards

Outline
1 Introduction: SwEng for ACI and Macro-programming
2 The Aggregate Computing (AC) approach to ACI engineering
3 Research Highlights
4 Wrap-up

Problem: artificial collective intelligence (ACI) eng. [30]
Artificial Collective Intelligence (ACI): the intelligence exhibited collectively by pluralities
of artificial agents
∠ Related term: Collective Adaptive System (CAS): a multitude of homogeneous agents
inter/acting and adapting as a whole with no central coordinator
e swarm missions: e.g., exploring an environment in formation, rescuing people, building a
communication network, dividing into teams...
e crowd management: e.g., computing the crowding level, providing suggestions for dispersal,
navigation, etc.
e smart city services: e.g., waste collection, pollution tracking
e computational ecosystems: e.g., crowdsourcing, edge-cloud task allocation
[30] R. Casadei. “Artificial Collective Intelligence Engineering: A Survey of Concepts and Perspectives”. In: Artif. Life
(2023)

Problem: artificial collective intelligence (ACI) eng. [30]
Artificial Collective Intelligence (ACI): the intelligence exhibited collectively by pluralities
of artificial agents
∠ Related term: Collective Adaptive System (CAS): a multitude of homogeneous agents
inter/acting and adapting as a whole with no central coordinator
e swarm missions: e.g., exploring an environment in formation, rescuing people, building a
communication network, dividing into teams...
e crowd management: e.g., computing the crowding level, providing suggestions for dispersal,
navigation, etc.
e smart city services: e.g., waste collection, pollution tracking
e computational ecosystems: e.g., crowdsourcing, edge-cloud task allocation
? RQ: how to effectively engineer the software supporting the emergence of ACI?
(2023)

Collective Intelligence (CI) taxonomy: 3 paradigms [66]
Generally, CI can be regarded as an aggregation of individual behavior results.
According to the existence of interactions between individuals and the feedback mechanism
in the aggregation process, CI can be divided into 3: paradigms
1) isolation (no interactions/feedback): individual ai autonomously act yielding result xi
∠ no interaction: results xi and xj do not influence each other
∠ no feedback: aggregation f(X) does not influence subsequent individual behaviors
2) collaboration (interaction but no feedback)
∠ no feedback: aggregation f(X, E) does not affect subsequent individual behaviors
3) feedback (interactions + feedback): f(Xt, Et) affects Xt+1 and Et+1
[66] F. He, Y. Pan, Q. Lin, X. Miao, and Z. Chen. “Collective Intelligence: A Taxonomy and Survey”. In: IEEE Access
(2019)

Scales, scopes, levels of a system
Scale: granularity of observation
∠ e.g., micro scale (people) and macro scale (group, crowd)
Scope: the boundaries of observation
∠ e.g., local scope (a robot’s neighbourhood) vs. global scope
Level: a system view defined through abstraction
∠ e.g., micro level ofmicro-scale entities; global level spanning the entire system
Multi-level modelling: methodology describing a system with multiple models at different
levels of detail [83]
∠ for accuracy vs. performance tradeoff (and reuse of models)
Physics and computer science have provided
evidence that macroscopic models can simplify
the description, analysis, or optimisation of
systems and processes [60, 83, 82]
[83] L. Serena, M. Marzolla, G. D’Angelo, and S. Ferretti. “A review of multilevel modeling and simulation for human
mobility and behavior”. In: Simulation Modelling Practice and Theory (Sept. 2023)

Scales, scopes, levels of a system
Scale: granularity of observation
∠ e.g., micro scale (people) and macro scale (group, crowd)
Scope: the boundaries of observation
∠ e.g., local scope (a robot’s neighbourhood) vs. global scope
Level: a system view defined through abstraction
∠ e.g., micro level ofmicro-scale entities; global level spanning the entire system
Multi-level modelling: methodology describing a system with multiple models at different
levels of detail [83]
∠ for accuracy vs. performance tradeoff (and reuse of models)
Physics and computer science have provided
evidence that macroscopic models can simplify
the description, analysis, or optimisation of
systems and processes [60, 83, 82]
What about multi-level models for control
purposes?
[83] L. Serena, M. Marzolla, G. D’Angelo, and S. Ferretti. “A review of multilevel modeling and simulation for human
mobility and behavior”. In: Simulation Modelling Practice and Theory (Sept. 2023)

ACI engineering: a taxonomy of approaches [28] [26]
behaviour-based: behaviours of robots are iteratively implemented, studied, and tuned until
desired collective behaviour is obtained
automatic (search-/optimisation-based): allow generation of behaviors without explicit
intervention of the developer
hybrid (semi-automatic): combine “iterative manual design” with automatic generation
ACI engineering methods
behaviour-based
methods
Probabilistic
FSM
virtual
physics-based
design
other
(amorphous, ...)
automatic
methods
MARL Evo
Program
Synthesis
hybrid
methods
AutoMoDE, ...
[28] M. Brambilla, E. Ferrante, M. Birattari, and M. Dorigo. “Swarm robotics: a review from the swarm engineering
perspective”. In: Swarm Intell. 1 (2013)
[26] M. Birattari, A. Ligot, and G. Francesca. “AutoMoDe: A Modular Approach to the Automatic Off-Line Design and
Fine-Tuning of Control Software for Robot Swarms”. In: Automated Design of Machine Learning and Search Algorithms.
Natural Computing Series. Springer, 2021

Language-based solutions at the macro-/global-level
architectural description languages [72]: aim at specifying the components of a system and
their relationships and constraints
multi-tier programming [88]: mixes the logic of components residing in different tiers (e.g.,
client-server architectures) in the same compilation unit
choreographies [62]: global-level descriptions of the communication protocol among
multiple parties is projected to synthesise correct implementations
multiagent-oriented programming [27]: cf. JaCaMo (agents, environment, organisations)
macroprogramming [31]: aims at expressing the macroscopic, global behaviour of an entire
system of agents or computing devices with a single program via macro-abstractions
Differentia, roughly
by target/assumptions: collectives vs. composites [69], agents vs. processes, ...
by goals: verification vs. behaviour
by abstractions: parties, channels, C&C, BDI, fields, ...
o quite a lot of fragmentation, and no unifying conceptual frameworks [56]

Macroprogramming [31] W
macro-
programming
environment
macro
program
macro
level
micro
level
micro
program(s)
macro-to-
micro
compilation
emergence
(micro-to-macro)
downward
causation
actual
macro
'emergence'
testing desired
macro
macro-
abstractions
global
scope
local
scope
micro
program(s)
micro
mechanisms
ai
E
f(E, { ai })
development
deployment
simulation/execution
analysis
Four principles
1. micro-macro distinction: multiple levels are considered
2. macroscopic perspective: high-level abstractions are considered
3. macro-program: specifies the global result/intent
4. macro-to-micro: the micro-level behaviour is determined by the macro-program
Macroprogramming as a general, fuzzy paradigm (cf. “declarative programming”) – no
formal definitions yet
[31] R. Casadei. “Macroprogramming: Concepts, State of the Art, and Opportunities of Macroscopic Behaviour
Modelling”. In: ACM Comput. Surv. 13s (2023)

Outline
Introduction
Model
Programming language (ScaFi)
4 Wrap-up

Intro Model PLs (ScaFi)
Aggregate computing/programming: overview [23] [86]
Aggregate programming: a macro-programming paradigm for self-organising /
collective systems
Origins: amorphous computing [1] (Proto), co-fields [67]—see [86] for history
System model: graph of nodes equipped with sensors/actuators
∠ links denote neighbours (communication via message-passing)
Execution model: async sense–compute–interact rounds
Abstraction: computational fields [86], i.e., maps dev/evt 7→ V from devices to values
Language: AC is formally captured by field calculi [12]
∠ Typical constructs: neighbourhood communication nbr(e); state evolution
rep(init)(f); domain branching branch(c){e1}{e2}
neighborhood
device
[86] M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini. “From distributed coordination to field
calculus and aggregate computing”. In: J. Log. Algebraic Methods Program. (2019)

Aggregate computing: introduction [86]
A historical view
the situation in 2019
currently, many goals partially achieved (apps,
lib, middleware, process mamobility), and new
directions (cf. AI, SE, more general
frameworks)—see next
[86] M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini. “From distributed coordination to field

Execution model: asynchronous sense–compute–interact rounds
A device “wakes up” and runs a round of execution, with 3 logical phases:
1. SENSE: get the local context (unexpired neighbour data + sensor data)
2. COMPUTE: run the aggregate program against the local context
3. INTERACT: run actuators and broadcast the same data to all the neighbours
the “aggregate program” is the same for all the devices, and yields the outgoing data
no synchronisation needed (once updates arrive, they are integrated)
Agent control architecture
agent
Computation round
Context
evaluation
Aggregate
program
evaluation
Context
action
Scheduling
policy
Sensors
State
Inbound
Message box
Outbound
Message box
Actuators
neighbours
Aggregate
program
0
1
2
3
Execution as event structures
δ0
δ1
δ2
δ3
δ4
device
time
0
0 0
1 0
2 0
3 0
4
1
0 1
1 1
2 1
3 1
4 1
5
2
0 2
1 2
2 2
3
3
0 3
1 3
2 3
3 3
4 3
5
4
0 4
1 4
2
m
e
s
s
a
g
e
self-message
reboot

The computational field abstraction (our “collective data structure”)
Metaphor: force/electromagnetic fields in physics
Related abstraction: artificial potential fields [87], co-fields [67]
∠ “abstract computational force fields (Co-Fields), generated by agents or the environment”
o data is conceptually attached to the environment
Computational fields: maps dev/evt 7→ V from devices to values
o data is conceptually attached to computational entities
e e.g.: collective movement (field of vectors), collective sensing (field of sensed data)
∠ static global view: D 7→ V (D is the set of device IDs, V any domain of values)
∠ static local view: Di 7→ V (Di is the neighbourhood of device i)
∠ dynamic global view: E 7→ V (E is the set of events—cf. rounds)
neighborhood
device
0
(x)=x+1
true t0,1

Aggregate programming with computational fields [12]
Computational fields
0
(x)=x+1
true t0,1
First-class (fields of) functions
()
0
1
+
-
1
-1
ef(0,1)
ef
Stateful evolution
rep
0
(x)=x+1
t
v0
t
v1
..
rep(0){(x)=x+1}
Interaction (neighbour communication)
nbr d
e
nbr{e}
φd=[d1→v1,..,dn→vn]
[12] G. Audrito, M. Viroli, F. Damiani, D. Pianini, and J. Beal. “A higher-order calculus of computational fields”. In:
ACM Transactions on Computational Logic (TOCL) 1 (2019)

Aggregate Computing as a layered engineering approach
sensors
local functions
actuators
Application
Code
Developer
APIs
Field Calculus
Constructs
Resilient
Coordination
Operators
Device
Capabilities
functions rep
nbr
T
G
C
functions
communication state
Perception
Perception
summarize
average
regionMax
…
Action
Action State
State
Collective Behavior
Collective Behavior
distanceTo
broadcast
partition
…
timer
lowpass
recentTrue
…
collectivePerception
collectiveSummary
managementRegions
…
Crowd Management
Crowd Management
dangerousDensity crowdTracking
crowdWarning safeDispersal
restriction
selfstabilisation

Aggregate Computing: ToolChain(s)
o as of 2019; not very up-to-date; now more languages/tools (FCPP, Collektive, ScaFiWeb)
and platforms (cf. works on pulverised middlewares—see next)

Aggregate Computing/Programming in 1 Slide
Self-org-like programming model
interaction: continuous msg exchange with neighbours
behaviour: continuous execution of async rounds of
sense – compute – (inter)act
abstraction: computational fields (dev/evt 7→ V)
paradigm: functional, macro-programming
formal model of executions: event structures
formal core language: field calculus [86]
semantics: (1) device; (2) network; (3) global comp.
sensors
local functions
actuators
Application
Code
Developer
APIs
Field Calculus
Constructs
Resilient
Coordination
Operators
Device
Capabilities
functions rep
nbr
T
G
C
functions
communication state
Perception
Perception
summarize
average
regionMax
…
Action
Action State
State
Collective Behavior
Collective Behavior
distanceTo
broadcast
partition
…
timer
lowpass
recentTrue
…
collectiveSummary
managementRegions
…
Crowd Management
Crowd Management
restriction
selfstabilisation
J. Beal, D. Pianini, and M. Viroli. “Aggregate programming for the internet of
things”. In: Computer 9 (2015)
δ0
δ1
δ2
δ3
δ4
device
time
0
0 0
1 0
2 0
3 0
4
1
0 1
1 1
2 1
3 1
4 1
5
2
0 2
1 2
2 2
3
3
0 3
1 3
2 3
3 3
4 3
5
4
0 4
1 4
2
m
e
s
s
a
g
e
self-message
reboot
source destination
gradient distance
gradient
=
+
dilate
width
37
10
1 def channel(source: Boolean, destination:
2 Boolean, width: Double) =
3 dilate(gradient(source) + gradient(destination) =
4 distance(source, destination), width)

ScaFi: overview [53]
ScaFi (Scala Fields) is an aggregate programming toolkit
Research tool/project started in 2016 by Viroli Casadei [38]
∠ Goal (short-term): exploit Scala features to implement an internal DSL for FC [12]
∠ Goal (long-term): promote research on self-organising systems programming CI
Tool paper in SoftwareX [53], formalisation in [15] (a FC variant: Neighbours Calculus)
Used in several research articles [45, 46, 34], the basis of the MacroSwarm lib [4]
Organisation/repos: https://github.com/scafi
∠ Main repo: https://github.com/scafi/scafi
∠ “Hello ScaFi” (headless): https://github.com/scafi/hello-scafi
∠ “Hello ScaFi + Alchemist” (GUI+map):
https://github.com/scafi/learning-scafi-alchemist
∠ other repos (cf. paper artefacts, other implementations, libraries)
Website (and docs): https://scafi.github.io
Online playground: https://scafi.github.io/web/ W
Û (live) a few examples abstracting from details
[15] G. Audrito, R. Casadei, F. Damiani, and M. Viroli. “Computation Against a Neighbour: Addressing Large-Scale
Distribution and Adaptivity with Functional Programming and Scala”. In: Log. Methods Comput. Sci. (Jan. 2023)
[4] G. Aguzzi, R. Casadei, and M. Viroli. “MacroSwarm: A Field-Based Compositional Framework for Swarm
Programming”. In: COORDINATION 2023, Proceedings. Lecture Notes in Computer Science. Springer, 2023
[53] R. Casadei, M. Viroli, G. Aguzzi, and D. Pianini. “ScaFi: A Scala DSL and Toolkit for Aggregate Programming”. In:
SoftwareX (2022)

ScaFi: syntax and DSL interface
Description Description
P Program F Function declaration
e Expression x Variable
v Value ` Local value
φ Field value f Function value
d Defined function b Built-in function
c Data constructor δ Device identifier
T Type B Built-in type
t Type variable TS Type scheme
D Type-scheme environment B Built-in type-scheme environment
A Type assumptions θ Value-tree
Θ Value-tree environment σ (Local) Sensor state
Ψ Value-tree field α Activation predicate
Stat Status Σ (Global) Sensor state
Env Environment N Network configuration
act Action label
P ::= F e program
F ::= def d(x) = @@{e} function declaration
e ::= x v (x) = @@{e} e(e) rep(e){e} nbr{e} expression
foldhood(e, e, e)
v ::= c(v) f value
f ::= b d (x) = @@{e} function value

1 trait Constructs {
2 def aggregate[A](f: = A): A // @@
3 def rep[A](init: A)(fun: (A) = A): A
4 def nbr[A](expr: = A): A
5 def foldhood[A](init: = A)(acc: (A,A)=A)(expr: = A): A
6
7 // Foundational built-ins
8 def mid(): ID
9 def sense[A](name: LSNS): A
10 def nbrvar[A](name: NSNS): A = // ...
11 def branch[A](cond: = Boolean)(th: = A)(el: = A): A = // ...
12 }
P ::= F e program
F ::= def d(x) = @@{e} function declaration
e ::= x v (x) = @@{e} e(e) rep(e){e} nbr{e} expression
foldhood(e, e, e)
v ::= c(v) f value
f ::= b d (x) = @@{e} function value

1 trait Constructs {
2 def aggregate[A](f: = A): A // @@
3 def rep[A](init: A)(fun: (A) = A): A
4 def nbr[A](expr: = A): A
5 def foldhood[A](init: = A)(acc: (A,A)=A)(expr: = A): A
6
7 // Foundational built-ins
8 def mid(): ID
9 def sense[A](name: LSNS): A
10 def nbrvar[A](name: NSNS): A = // ...
11 def branch[A](cond: = Boolean)(th: = A)(el: = A): A = // ...
12 }

Semantics: two main pieces [15]
Device semantics (big-step op-sem): captures program evaluation (one round)
δ, δ0
; Θ; σ ` e ⇓ θ
“expression e evaluates to value-tree θ on device δ with respect to the neighbour δ0
,
value-tree environment Θ and sensor state σ”
communication based on structural alignment of value-trees

Semantics: two main pieces [15]
Device semantics (big-step op-sem): captures program evaluation (one round)
δ, δ0
; Θ; σ ` e ⇓ θ
“expression e evaluates to value-tree θ on device δ with respect to the neighbour δ0
,
value-tree environment Θ and sensor state σ”
communication based on structural alignment of value-trees
Network semantics (small-step op-sem): captures system executions
N
act
−
−
→ N
network evolves through
∠ act = δ+ (device computation)
∠ act = δ− (communication)
∠ act = env (environment evolution)

Device semantics (big-step) [15]
Value-trees and value-tree environments:
θ ::= vhθi value-tree
Θ ::= δ 7→ θ value-tree environment
Rules for expression evaluation: δ, δ
0
; Θ; σ ` e ⇓ θ
[E-VAL]
δ, δ0; Θ; σ ` v ⇓ vhi
[E-B-APP]
δ, δ; π1(Θ); σ ` e ⇓ θ δ, δ0; πi+1(Θ); σ ` ei ⇓ θi for all i ∈ 1, . . . , n
v = LbM
πb(Θ),σ
δ,δ0 (ρ(θ)) (b = ρ(θ) is not relational ) ∨ (δ0 ∈ dom(πb(Θ)) ∪ {δ})
δ, δ0; Θ; σ ` e(e) ⇓ vhθ, θ, vi
[E-D-APP]
δ, δ; π1(Θ); σ ` e ⇓ θ δ, δ0; πi+1(Θ); σ ` ei ⇓ θi for all i ∈ 1, . . . , n
f = ρ(θ) is not a built-in δ, δ0; πf(Θ); σ ` body(f)[args(f) := ρ(θ)] ⇓ θ0
δ, δ0; Θ; σ ` e(e) ⇓ ρ(θ0)hθ, θ, θ0i
[E-REP]
δ, δ; π1(Θ); σ ` e1 ⇓ θ1 v1 = ρ(θ1)
δ, δ; π2(Θ); σ ` e2(v0) ⇓ θ2 v2 = ρ(θ2)
v0 =

ρ(π2(Θ))(δ) if δ ∈ dom(Θ)
v1 otherwise
δ, δ0; Θ; σ ` rep(e1){e2} ⇓ v2hθ1, θ2i
[E-NBR] δ 6= δ0 ∈ dom(Θ) θ = Θ(δ0)
δ, δ0; Θ; σ ` nbr{e} ⇓ θ
[E-NBR-LOC] δ, δ; π1(Θ); σ ` e ⇓ θ
δ, δ; Θ; σ ` nbr{e} ⇓ ρ(θ)hθi
[E-FOLD]
δ, δ; π1(Θ); σ ` e1 ⇓ θ1 δ, δ; π2(Θ); σ ` e2 ⇓ θf f = ρ(θf )
δ1, . . . , δn = dom(Θ) {δ} n ≥ m ≥ 0, δ1, . . . , δm increasing, δ0 = δ
δ, δi; π3(Θ); σ ` e3 ⇓ θi for all i ∈ 0, ..., m
δ, δj ; π3(Θ); σ ` e3 FAIL for all j ∈ m + 1, ..., n
δ, δ; ∅; σ ` f(ρ(θi), ρ(θi)) ⇓ θi+1 for all i ∈ 1, ..., m
δ, δ0; Θ; σ ` foldhood(e1, e2, e3) ⇓ ρ(θm+1)hθ1, θf , θ0i

Network semantics (small-step, SOS) [15]
System configurations and action labels:
Ψ ::= δ 7→ Θ value-tree field
α ::= δ 7→ a with a ∈ {false, true} activation predicate
Stat ::= Ψ, α status
τ ::= hδ, δ
0
i topology
Σ ::= δ 7→ σ sensor state
Env ::= τ, Σ environment
N ::= hEnv; Stati network configuration
act ::= δ+ δ− env action label
Environment well-formedness:
WFE(τ, Σ) holds iff {hδ, δi | δ ∈ D} ⊆ τ ⊆ D × D where D = dom(Σ)
Transition rules for network evolution: N
act
−
−
→ N
[N-COMP] α(δ)=false Θ0
= Fδ(Ψ(δ)) δ, δ; Θ0
; Σ(δ) ` emain ⇓ θ Θ=Θ0
[δ 7→ θ]
hτ, Σ; Ψ, αi
δ+
−
−
→ hτ, Σ; Ψ[δ 7→ Θ], α[δ 7→ true]i
[N-SEND] α(δ)=true δ =

δ0
| δτδ0
θ = Ψ(δ)(δ) Θ = δ 7→ θ
hτ, Σ; Ψ, αi
δ−
−
−
→ hτ, Σ; ΨJδ 7→ ΘK, α[δ 7→ false]i
[N-ENV] WFE(Env0
) Env0
= τ, δ 7→ σ Ψ0 = δ 7→ ∅ α0 = δ 7→ false
hEnv; Ψ, αi
env
−
−
→ hEnv0
; Ψ0[Ψ], α0[α]i

Using ScaFi (standalone) 1
0) Clone and run
1 $ git clone git@github.com:scafi/hello-scafi.git cd hello-scafi
2 $ ./gradlew run # run with gradle
3 $ sbt run # run with sbt
1) Import ScaFi as a dependency (e.g., through Gradle)
build.gradle.kts
1 plugins { scala }
2 repositories { mavenCentral() }
3 dependencies {
4 implementation(org.scala-lang:scala-library:2.13.12)
5 implementation(it.unibo.scafi:scafi-core_2.13:1.1.5)
6 }
2) Write a ScaFi program
1 // 1. Define (or import) an incarnation, which provides an instantiation of types and other
classes to import
2 object MyIncarnation extends BasicAbstractIncarnation
3
4 // 2. Bring into scope the stuff from the chosen incarnation
5 import examples.MyIncarnation._
6
7 // 3. Define an aggregate program using the ScaFi DSL by extending AggregateProgram and
specifying a main expression
8 class BasicUsageProgram extends AggregateProgram {
9 override def main(): Any = rep(0)(_+1)
10 }
3) Make up an “aggregate system” (create/deploy/connect multiple nodes repeatedly
communicating and executing the aggregate program in a loop) W
1https://github.com/scafi/hello-scafi

Examples
Web playground: https://scafi.github.io/web/W [9]
[9] G. Aguzzi, R. Casadei, N. Maltoni, D. Pianini, and M. Viroli. “ScaFi-Web: A Web-Based Application for Field-Based
Coordination Programming”. In: COORDINATION 2021, , Proceedings. Lecture Notes in Computer Science. Springer,
2021

Examples: gradient [14]
Gradient: resiliently build the field of shortest distances from a source area
Multiple algorithms for self-healing gradients exist, with different tradeoffs in terms of
simplicity, assumptions, reactivity, smoothness, etc. [14]
[14] G. Audrito, R. Casadei, F. Damiani, and M. Viroli. “Compositional blocks for optimal self-healing gradients”. In:
2017 IEEE 11th International Conference on Self-Adaptive and Self-Organizing Systems (SASO). IEEE. 2017

More on the gradient building block
1 def gradient(source: Boolean, metric: () = Double = nbrRange): Double =
2 rep(Double.PositiveInfinity){ distance =
3 mux(source) { // Source devices yield 0.0
4 0.0
5 }{ // Others minimise over neighbours' gradient value + distance
6 foldhoodPlus(Double.PositiveInfinity)(Math.min(_,_)){
7 nbr{distance} + metric()
8 }
9 }
10 } // NOTE: no Field[T] types (but 'fields' still useful, conceptually)
Example of stabilised gradient
Dynamic view (another example)

From building blocks to applications
Applications are built by composing functions of fields
∠ each function comprises behaviour + interaction
∠ each function generally steers some emergent collective behaviour
∠ output of a function (namely a field) becomes the input of another
1 def channel(source: Boolean,
2 target: Boolean,
3 width: Double) = dilate(
4 gradient(source) + gradient(target) =
5 distance(source, target)
6 ), width)
7
8 def gradient(source: Boolean): Double = // see prev slide
9
10 def distance(A: Boolean, B: Boolean): Double =
11 broadcast(a, gradient(b))
12
13 def broadcast[T](a: Boolean, v: T): T = // similar to
gradient
source destination
gradient distance
gradient
=
+
dilate
width
37
10

“Generalised operators”
G: spreading
3
1
7
0
2
T: time decay
1
4
3
3
C: collecting

Domain-specific librariesa high-level
Macro Swarm
Base Movement
Flocking
Leader Based
Team Formation Pattern Formation Swarm
Planning
Resilient
Coordination
Operators
C G S
Field-Coordination
Constructs
rep nbr branch
vShape line centeredCircle
plan
separation
execute
cohesion align
sinkAt alignWith
isTeamFormed teamFormation
goTo
explore
brownian
maintainUntil

Examples: channel (around obstacles) (1/3)
Channel: resiliently define a domain of devices providing the shortest path from a
source area to a destination area

Outline
General
Language extensions
Algorithms and Patterns
Middleware deployment
Artificial Intelligence / Machine Learning
Applications
4 Wrap-up

General Language extensions Algorithms and Patterns Middleware deployment AI / ML Applications
SwEng for Collective Cyber-Physical Ecosystems [56]
Properties (Sec. 2)
Motivate
Collective Cyber-Physical
Collective
Ecosystem
Cyber-Physical
Themes (Sec. 3) Challenges (Sec. 5)
C1. Homogeneity vs. Heterogeneity (Sec. 5.1)
C2. Specifying and Running CCPEs (Sec. 5.2)
C5. Integration of Humans (Sec. 5.5)
C3. Learning collective behaviour (Sec. 5.3)
C6. Safety and Security (Sec. 5.6)
C4. Veriﬁcation and Validation of CCPEs (Sec. 5.4)
T2. Local-Global Relations (Sec 3.2)
T1. Collective Intelligence (Sec 3.1)
T3. Automatic vs Manual (Sec 3.3)
vs
vs
?
Large-scale
Applications (Sec. 2.3)
Swarm Robotics Crowd Management Smart Cities
Cyber-physical
Cooperative Behaviour
Distribution
Situatedness
Software Engineering
Industrial IoT
State of the art (Sec. 4)
Composite-oriented (Sec 4.1)
Distributed Interactive
Systems.
Cyber-Physical Systems
Multi-Agent Systems
Self-Adaptive Systems
Collective Adaptive Systems
Macro-programming
Collective-oriented (Sec 4.2)
Multi-agent learning
[56] R. Casadei, G. Aguzzi, G. Audrito, F. Damiani, D. Pianini, G. Scarso, G. Torta, and M. Viroli. “Software
Engineering for Collective Cyber-Physical Ecosystems”. In: ACM Trans. Softw. Eng. Methodol. (2025)

The eXchange Calculus (XC) [22]
The eXchange Calculus (XC): subsumes and extends field calculi
1. more minimal: uses a single construct (+ built-ins): exchange (for both stateful evolution and
communication)
2. more expressive/general: allows for differentiated messages to neighbours via NValues of
form `[δi 7→ ì, . . .] which mean
(receiver side): neighbour δi sent me value ì (or ` by default)
(sender side): I send value ì to neighbour δi (and ` to other neighbours)
1 def distanceEstimate(n) { // type: (num) - num
2 nfold(min, n + senseDistance, Infinity)
3 } // nfold(f, nvalue, valueForSelf)
4
5 def distanceTo(src) { // type: (bool) - num
6 exchange(Infinity, (n) = retsend mux(src, 0, distanceEstimate(n)))
7 } // retsend x = return x send x (can distinguish sent vs. returned data)
[22] G. Audrito, R. Casadei, F. Damiani, G. Salvaneschi, and M. Viroli. “The eXchange Calculus (XC): A functional
programming language design for distributed collective systems”. In: Journal of Systems and Software (2024)

Time-fluid field computations [80] W
A causality-based scheduling framework for aggregate computations
Idea: from periodic rounds to reactive computations, for efficiency
Has position
changed at least of ?
Has neighbourhood
changed?
Has the gradient value
of a neighbour
Position
changed?
nbrs
New message
for gradient?
gradient
Has position
Has neighbourhood
changed?
Has the gradient value
of a neighbour
Position
changed?
nbrs
New message
for gradient?
gradient
changed?
changed?
distanceBetween channel
[80] D. Pianini, R. Casadei, M. Viroli, S. Mariani, and F. Zambonelli. “Time-Fluid Field-Based Coordination through
Programmable Distributed Schedulers”. In: Log. Methods Comput. Sci. (Nov. 2021)

FRASP: functional reactive AC [54] [talk: W]
FRASP (Functional Reactive Approach to Self-organisation Programming): a FRP-based
reimplementation of AC
Videos:
∠ Gradient example: https://youtu.be/3QIWfNq3yxU
∠ Channel example: https://youtu.be/j_JX5wW03-w
Channel
gradient
(source)
gradient
(destination)
distanceBetween
source destination
Sub-
computations
Computation
Sensors
nbrRange
Input
Width
Platform
Local sensors
Neighbour data
[54] R. Casadei, F. Dente, G. Aguzzi, D. Pianini, and M. Viroli. “Self-Organisation Programming: A Functional
Reactive Macro Approach”. In: ACSOS 2023. IEEE, 2023

Aggregate processes [45] W
Concurrent, dynamic, overlapping collective tasks with evolving domains
? how would you code in ScaFi a limited multi-gradient for arbitrary sources?
1 def multiGradient(isSrc: Boolean, maxExtension: Double) =
2 spawn[ID,Double,Double](src = limit =
3 gradient(src==mid,nbrRange) match { // consider the usual gradient
4 case g if src==mid !isSrc = (g, Terminated) // close on unsource
5 case g if glimit = (g, External) // out of bubble
6 case g = (g, Output) // in bubble + get
7 },
8 newKeys = if(isSrc) Set(mid) else Set.empty,
9 args = maxExtension
10 )
[45] R. Casadei, M. Viroli, G. Audrito, D. Pianini, and F. Damiani. “Engineering collective intelligence at the edge with
aggregate processes”. In: Engineering Applications of Artificial Intelligence (2020)

Aggregate processes: patterns [32]
[32] R. Casadei. “System-Wide IoT design and programming: Patterns for decentralised collective processes”. In:
Internet of Things (Dec. 2024)

Aggregate processes: patterns [32]
Notation:
∠ squares are “carrier processes” (needed to “avoid process loss”)
∠ coloured circles are space-attached processes
∠ different colours denote different instances

Self-organising / self-stabilising algorithms
E.g.: gradients [14], distributed summarisation/collection [19], leader election [74]
[14] G. Audrito, R. Casadei, F. Damiani, and M. Viroli. “Compositional blocks for optimal self-healing gradients”. In:
2017 IEEE 11th International Conference on Self-Adaptive and Self-Organizing Systems (SASO). IEEE. 2017
[19] G. Audrito, R. Casadei, F. Damiani, D. Pianini, and M. Viroli. “Optimal resilient distributed data collection in mobile
edge environments”. In: Computers Electrical Engineering (2021)
[74] D. Pianini, R. Casadei, and M. Viroli. “Self-stabilising Priority-Based Multi-Leader Election and Network
Partitioning”. In: IEEE International Conference on Autonomic Computing and Self-Organizing Systems, ACSOS 2022.
IEEE, 2022

Self-Organising Coordination Regions (SCR) [79]
It allows to dynamically
adjust the level of
decentralisation in a system
SCR pattern code
1 val metric = // ...
2 val leader = S(metric)
3 val g = gradient(leader)
4 val data = C(g, ...)
5 val decision = G(g, ...)
[79] D. Pianini, R. Casadei, M. Viroli, and A. Natali. “Partitioned integration and coordination via the self-organising
coordination regions pattern”. In: Future Gener. Comput. Syst. (2021)

Space-fluid field computations [58]
Motivation: adaptive spatial clustering/sampling (e.g., tracking pollution)
a leader election-induced regional partitioning field
[58] R. Casadei, S. Mariani, D. Pianini, M. Viroli, and F. Zambonelli. “Space-Fluid Adaptive Sampling by
Self-Organisation”. In: Logical Methods in Computer Science (Dec. 2023)

Space-fluid field computations [58]
Motivation: adaptive spatial clustering/sampling (e.g., tracking pollution)
[58] R. Casadei, S. Mariani, D. Pianini, M. Viroli, and F. Zambonelli. “Space-Fluid Adaptive Sampling by
Self-Organisation”. In: Logical Methods in Computer Science (Dec. 2023)

Pulverisation W
A model for partitioning/deployment of AC systems [52]
logical
device
β
behaviour
χ
communication
κ state
σ
sensors
α
actuators
neighbour
device
χ β
κ
σ α
σ χ
α
β
κ
χ α
σ
β
κ
σ α
χ
β
κ
σ α
β
χ
κ
σ α
χ
β
κ
σ α
χ
β
κ
σ α
χ
β
κ
Host (thin/application-level)
Host (thick/infrastructure-level)
Logical device
σ Device’s sensor set
α Device’s actuator set
χ Device’s communication interface
κ Device’s state
β Device’s behaviour
Host-to-host link
Logical, neighbouring link
Twin relationship
δ1
δ2
δ3
δ5
δ4
β1
α1
σ1
χ1
κ1
α2
χ2
σ2
β2
κ2
α3
σ3
χ3
β3
κ3
α4
σ4
χ4
β4
κ4
α5
σ5
χ5
β5
κ5
[52] R. Casadei, D. Pianini, A. Placuzzi, M. Viroli, and D. Weyns. “Pulverization in Cyber-Physical Systems:
Engineering the Self-Organizing Logic Separated from Deployment”. In: Future Internet 11 (2020)

A sim-based methodology for deployment evaluation [42]
IoT
Edge
Fog
Cloud
Available / Target
ICT infrastructure.
System
behaviour
specification
ICT
infrastructure
model
Functional
requirements
Application
Partitioning
Partitioned Application
Deployment Generator
Deployment
A
Simulator
Protelis
EdgeCloudSim
Analysis Results
(cost, performance...)
Pulverisation
Pulverised
aggregate
system
Deployment
B
Deployment
C
B S K
C A
[42] R. Casadei, G. Fortino, D. Pianini, A. Placuzzi, C. Savaglio, and M. Viroli. “A Methodology and Simulation-based
Toolchain for Estimating Deployment Performance of Smart Collective Services at the Edge”. In: IEEE Internet Things J.
(2022)

PulvReAKt: DSLs/Middleware for AC reconfig. [65]
Idea: use DSLs to describe pulverised AC deployments and reconfig. policies
[65] N. Farabegoli, D. Pianini, R. Casadei, and M. Viroli. “Scalability through Pulverisation: Declarative deployment
reconfiguration at runtime”. In: Future Generation Computer Systems (Dec. 2024)

AC for self-org. deployment reconfig. [64]
Idea: using AC to specify global-level deployment reconfig. policies (e.g., via SCR)
[64] N. Farabegoli, D. Pianini, R. Casadei, and M. Viroli. “Dynamic IoT deployment reconfiguration: A global-level
self-organisation approach”. In: Internet of Things (Dec. 2024)

AC for self-org. deployment reconfig. [64]
Idea: using AC to specify global-level deployment reconfig. policies (e.g., via SCR)
output: a “deployment field” (each node returns the set of components to host)
[64] N. Farabegoli, D. Pianini, R. Casadei, and M. Viroli. “Dynamic IoT deployment reconfiguration: A global-level
self-organisation approach”. In: Internet of Things (Dec. 2024)

Flexible deployment of macro-programs [63]
Idea: AC app partitioning by functional decomposition (unlike pulverisation)
[63] N. Farabegoli, M. Viroli, and R. Casadei. “Flexible Self-organisation for the Cloud-Edge Continuum: a
Macro-programming Approach”. In: IEEE International Conference on Autonomic Computing and Self-Organizing
Systems, ACSOS 2024, Aarhus, Denmark, Sep 16-20, 2024. IEEE, 2024

Distributed Collective ML
Roadmap
Goal
effective efficient
aggregate
behaviours
Learning
Programs /
Algorithms
Learning
Execution
Strategy
Learning
Aggregate
Computing
Deployments
Starting Point
Hand-crafted
solutions
Challenges
Opportunities
Collective
Intelligence
Green Autonomic
Computing
Multi-agent
Learning
Program Synthesis
Application
Middleware
System
Structure
ULT
SVD
FLEX
Distributed
Schedulers
Pulverised
Architectures
Use ML to improve aggregate
computations at different levels
∠ algorithm/application level
∠ execution level
∠ deployment level?
[3]: G. Aguzzi, R. Casadei, and M. Viroli. “Machine Learning for Aggregate
Computing: a Research Roadmap”. In: 42nd IEEE International Conference on
Distributed Computing Systems, ICDCS Workshops, Bologna, Italy, July 10, 2022.
IEEE, 2022
Program synthesis
Environment
Agent
Computation round
Context
evaluation
Aggregate
program
evaluation
Context
action
Scheduling
policy
Sensors
State
Inbound
Message box
Outbound
Message box
Actuators
neighbours
Aggregate
program
0
1
2
3
RL
[5]: G. Aguzzi, R. Casadei, and M. Viroli. “Towards Reinforcement
Learning-based Aggregate Computing”. In: COORDINATION 2022 Proceedings.
Lecture Notes in Computer Science. Springer, 2022
ML for improved scheduling
Sensors
Actuation
Communication
Scheduler
Local State
Execution
Platform Program
Environment
Neighbourhood
Agent
[2]: G. Aguzzi, R. Casadei, and M. Viroli. “Addressing Collective Computations
Efficiency: Towards a Platform-level Reinforcement Learning Approach”. In:
ACSOS 2022. IEEE, 2022

Distributed Collective ML
Roadmap [3]
Goal
effective efficient
aggregate
behaviours
Learning
Programs /
Algorithms
Learning
Execution
Strategy
Learning
Aggregate
Computing
Deployments
Starting Point
Hand-crafted
solutions
Challenges
Opportunities
Collective
Intelligence
Green Autonomic
Computing
Multi-agent
Learning
Program Synthesis
Application
Middleware
System
Structure
ULT
SVD
FLEX
Distributed
Schedulers
Pulverised
Architectures
[3] G. Aguzzi, R. Casadei, and M. Viroli. “Machine Learning for Aggregate Computing: a Research Roadmap”. In:
42nd IEEE International Conference on Distributed Computing Systems, ICDCS Workshops, Bologna, Italy, July 10, 2022.
IEEE, 2022

Sketching gradients and RL-based AC [5] [repo: W]
Environment
Agent
Computation round
Context
evaluation
Aggregate
program
evaluation
Context
action
Scheduling
policy
Sensors
State
Inbound
Message box
Outbound
Message box
Actuators
neighbours
Aggregate
program
0
1
2
3
RL
Simulation
Learn process
i-th episode
1 def optBlock(ot−1) { // learning as a field that evolves in time
2 rep((s0, a0, o0)) { case (st−1, at−1, _) = { // s0, a0 context dependent
3 val Q = sense(Q) // global during training, local during execution
4 val ot = update(ot−1, at−1) // local action
5 // state from the neighbourhood field program output
6 val st = state(nbr(ot))
7 val at = branch(learn) { // actions depends on learn condition
8 val rt−1 = reward(ot, simulation) // simulation is a global object
9 simulation.updateQ(Q, st−1, at−1, rt−1, st) // Q update
10 ∼ π
Q
behavioural
(st) // sample from a probabilistic distribution
11 } { π
Q
target(st) } // greedy policy, no sampling is needed
12 (st, at, ot)
13 } }._3 // select the output from the tuple
14 }
15 def gradientOpt(src, metric, opt) = rep(infinity) { g = mux(src){ 0 }{ opt(g, metric)) }
[5] G. Aguzzi, R. Casadei, and M. Viroli. “Towards Reinforcement Learning-based Aggregate Computing”. In:
COORDINATION 2022 Proceedings. Lecture Notes in Computer Science. Springer, 2022

MacroSwarm: a DSL for swarm programming [4]
MacroSwarm: a high-level API (backed by AC) for programming swarms
Experiments: https://github.com/AggregateComputing/
experiment-2023-coordination-swarm-behaviour
Video: https://youtu.be/1HKVlY-8bZY
Presentation (by G. Aguzzi): W
Macro Swarm
Base Movement
Flocking
Leader Based
Team Formation Pattern Formation Swarm
Planning
Resilient
Coordination
Operators
C G S
Field-Coordination
Constructs
rep nbr branch
vShape line centeredCircle
plan
separation
execute
cohesion align
sinkAt alignWith
isTeamFormed teamFormation
goTo
explore
brownian
maintainUntil
Programming”. In: COORDINATION 2023, Proceedings. Lecture Notes in Computer Science. Springer, 2023

FieldVMC: morphogenesis [61] W
Idea: AC to program morphogenetic processes
∠ Generalising the botany-inspired Vascular Morphogenesis Controller (VMC) by Payam et al.
[61] A. Cortecchia, D. Pianini, G. Ciatto, and R. Casadei. “An Aggregate Vascular Morphogenesis Controller for
Engineered Self-Organising Spatial Structures”. In: IEEE International Conference on Autonomic Computing and
Self-Organizing Systems, ACSOS 2024, Aarhus, Denmark, Sep 16-20, 2024. IEEE, 2024

Situated tuples [59] [81] W
Inspired by the Spatial Tuples
model for spatial coordination
Tuples/operations become
“aggregate processes” living in
multiple devices
time
space
out †
out
rd †
rd
M
time
space/devices
out
in
M
0
in
0
M
C
†
in
†
out
[59] R. Casadei, M. Viroli, A. Ricci, and G. Audrito. “Tuple-Based Coordination in Large-Scale Situated Systems”. In:
COORDINATION 2021, Proceedings. LNCS. Springer, 2021

Virtual devices for improved self-organisation [44]
Idea: synthesising virtual devices to steer a self-organising behaviour (w/o changing it)
∠ a.k.a. shill agents, soft control, pseudo-emergence, ...
[44] R. Casadei, D. Pianini, M. Viroli, and D. Weyns. “Digital Twins, Virtual Devices, and Augmentations for
Self-Organising Cyber-Physical Collectives”. In: Applied Sciences 1 (Dec. 2021)

Crowd management [23, 48]
sensors
local functions
actuators
Application
Code
Developer
APIs
Field Calculus
Constructs
Resilient
Coordination
Operators
Device
Capabilities
functions rep
nbr
T
G
C
functions
communication state
Perception
Perception
summarize
average
regionMax
…
Action
Action State
State
Collective Behavior
Collective Behavior
distanceTo
broadcast
partition
…
timer
lowpass
recentTrue
…
collectiveSummary
managementRegions
…
Crowd Management
Crowd Management
restriction
selfstabilisation

Runtime verification monitoring of spatial properties [13]
mapping of Spatial Logic for Closure Spaces (SLCS) formulas to FC programs
example: D =⇒ (D U(¬D R B)), i.e., “dangerous areas (D) are surrounded by (U)
devices (¬D) which can safely reach (R) a base (B)”
1 let D = crowding == OVERCROWDED || crowding == AT_RISK;
2 let B = env.get(isSafePlace); // blu squares
3 implies(D, surroundedBy(D, reaches(!D, B)))
[13] G. Audrito, R. Casadei, F. Damiani, V. Stolz, and M. Viroli. “Adaptive distributed monitors of spatial properties for
cyber-physical systems”. In: J. Syst. Softw. (2021)

Crowd Digital Twins [49]
Crowd digital twin: the digital twin of a physical crowd of humans
physical environment
physical
crowd
environmental
sensors
(e.g., cameras)
and actuators
(e.g., lights and
mobile barriers)
stakeholders
crowd digital twin
data
warehouse
models
prediction
planning
environment
digital twin
external
services
wearables
sensors /
actuators
human group
digital twin
[49] R. Casadei, G. Delnevo, R. Girau, and S. Mirri. “Modelling Groups of Humans: Towards Crowd Digital Twins”. In:
2024 IEEE Symposium on Computers and Communications (ISCC). IEEE, June 2024

Crowd Digital Twins [49]
Crowd digital twin: the digital twin of a physical crowd of humans
digital interface
managing system
Knowledge
cyber-physical network interface
PHYSICAL
LAYER
CYBER-
PHYSICAL
LAYER
humans
sensors actuators
mobile robots
Monitor Analyze Plan Execute
CDT Core Models
(crowd +
environment)
APPLICATION
LAYER
SERVICE
LAYER Visualization Administration
Adaptation
Goals
AUTONOMIC
LAYER
crowd
management
emergency
management
crowd-aware
services
physical
crowdsourcing
elements
Surrogate
Models
Simulation
Models
Analytics
Device
Models
Config.
Models
macro-
component
component Model
application
types
Data exchange
Logical
association
Legend
Meta-
models
Learning
Models
..
communication
[49] R. Casadei, G. Delnevo, R. Girau, and S. Mirri. “Modelling Groups of Humans: Towards Crowd Digital Twins”. In:
2024 IEEE Symposium on Computers and Communications (ISCC). IEEE, June 2024

Computational trust [34]
Idea: using neighbouring observations to build “fields of trust”
∠ in the paper: used to detect “fake” devices (e.g., malicious or fake nodes)
[34] R. Casadei, A. Aldini, and M. Viroli. “Towards attack-resistant aggregate computing using trust mechanisms”. In:
Science of Computer Programming (2018)

Conclusion
The engineering artificial collective intelligence (ACI) is a fascinating research thread
Macro-programming aims to bring benefits (simplified descriptions + dynamic optimisation)
to developers through declarativity [36]
Aggregate computing: a macro-programming paradigm for self-org / collective systems
∠ promoting research on collective computation models, programming languages, distributed
algorithms, distributed middleware, and more
Thanks to: Viroli, Damiani, Audrito, Pianini, Aguzzi, and many others
macro-
programming
environment
macro
program
macro
level
micro
level
micro
program(s)
macro-to-
micro
compilation
emergence
(micro-to-macro)
downward
causation
actual
macro
'emergence'
testing desired
macro
macro-
abstractions
global
scope
local
scope
micro
program(s)
micro
mechanisms
ai
E
f(E, { ai })
development
deployment
simulation/execution
analysis

Interesting directions for further research—see also [56]
Investigating macro-programming at a more foundational level
Investigating software engineering techniques tailored to collective systems
∠ including analysis and testing of “emergent behaviour”
Investigating hybrid methods combining macro-programming and AI-directed program
synthesis
[56] R. Casadei, G. Aguzzi, G. Audrito, F. Damiani, D. Pianini, G. Scarso, G. Torta, and M. Viroli. “Software

A research map through selected papers
R. Casadei. “Artificial Collective Intelligence Engineering: A Survey of Concepts and
Perspectives”. In: Artif. Life (2023)
∠ It frames the general problem – the principled ACI engineering by a CS/SE perspective –
and provides a research map.
R. Casadei, G. Aguzzi, G. Audrito, F. Damiani, D. Pianini, G. Scarso, G. Torta, and M. Viroli.
“Software Engineering for Collective Cyber-Physical Ecosystems”. In: ACM Trans. Softw.
Eng. Methodol. (2025)
∠ It offers a comprehensive research agenda on software engineering for ACI, considering
AI, macro-programming, hybrid methods—with corresponding research challenges.
R. Casadei, F. Fornari, S. Mariani, and C. Savaglio. “Programming IoT systems: A focused
conceptual framework and survey of approaches”. In: Internet of Things (Feb. 2025)
∠ A broad survey on IoT programming.
R. Casadei. “Macroprogramming: Concepts, State of the Art, and Opportunities of
Macroscopic Behaviour Modelling”. In: ACM Comput. Surv. 13s (2023)
∠ It provides a survey and conceptual framework for “macro-programming”: the use of
programming languages to describe macro-scopic outcomes and use these to drive
micro-level activity.
M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini. “From distributed
coordination to field calculus and aggregate computing”. In: J. Log. Algebraic Methods
Program. (2019)
∠ It provides a survey, history, and research agenda on a specific macro-programming
approach a.k.a. aggregate computing.

Aggregate Computing (AC) research map (1/4)
The development of an ACI paradigm, from science to engineering
Foundations
Origins and research threads
∠ Field-based coordination [86]
∠ Spatial computing [24]
∠ Macroprogramming [31]
∠ Collective adaptive systems and ensembles [71]
Computational models and languages (for distribution, self-organization) W
∠ Field calculus constructs and variants [12, 17, 15]
∠ Aggregate processes [43, 45]
∠ Time-fluid and reactive aggregate computing [80]
Main formal results
∠ Self-stabilization [85]
∠ Density-independence [25]
∠ Space-time universality [21]
[86] M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini. “From distributed coordination
to field calculus and aggregate computing”. In: J. Log. Algebraic Methods Program. (2019)

Building aggregate computing systems
Algorithms/patterns
∠ Gradients [14, 85]
∠ Distributed collection/summarisation [19]
∠ Leader Election [70]
∠ Higher-level patterns: Self-Organising Coordination Regions [55, 79]
Platforms, distributed systems, and deployments W
∠ Cloud vs. edge deployments [48, 40]
∠ Flexible deployment via pulverisation [52]
∠ Multi-tier programming of pulverised architectures [10]
∠ Virtual devices and collective digital twins [44]
Tools
∠ ScaFi: a Scala-internal DSL and toolkit [38, 45, 47, 15] W
∠ Protelis: a standalone DSL [77] built in Xtext W
∠ FCPP: a C++-internal DSL and toolkit [11] W
∠ Alchemist simulator [76, 73] W

Research directions
Coordination models and languages [86]
∠ situated tuples [39, 59] W
Agent-oriented programming (AOP) [84] and autonomous systems [33]
Collective intelligence [45]
Macroprogramming [31, 24]
IoT/Edge resource coordination [48, 35] W
Robot self-assembly, morphogenesis?
Computational trust (e.g., for collaborative tasks) [34]
Topology (e.g., sheaf theory, coordinate-free coverage in WSNs..) [75]
Decentralised runtime monitoring of spatio-temporal properties [13]
Real-time AC [16]
Relationships with other paradigms
∠ e.g., context-oriented programming [50]

Application scenarios
Crowd management [23, 48]
Smart ecosystems, IoT
∠ Smart city (e.g., intelligent lighting) [79]
∠ Smart buildings [68], Industry 4.0 [46]
∠ WSNs, distributed sensing [37, 19]
Environmental monitoring control
∠ pollution-aware household heating monitoring control [52]
∠ wildlife monitoring and rescue [33]
Swarm intelligence (robots, drones) [45]
∠ Modular robotics/ morphogenesis [61]
∠ Rescue scenarios and tactical networks [84, 59]
Edge-cloud continuum (e.g., workload management, deployment reconfiguration) [79, 64]

References (1/10)
[1] H. Abelson and N. Forbes. “Amorphous computing”. In: Complex. 5.3 (2000), pp. 22–25.
[2] G. Aguzzi, R. Casadei, and M. Viroli. “Addressing Collective Computations Efficiency: Towards a Platform-level
Reinforcement Learning Approach”. In: ACSOS 2022. IEEE, 2022, pp. 11–20. DOI:
10.1109/ACSOS55765.2022.00019.
[3] G. Aguzzi, R. Casadei, and M. Viroli. “Machine Learning for Aggregate Computing: a Research Roadmap”. In:
42nd IEEE International Conference on Distributed Computing Systems, ICDCS Workshops, Bologna, Italy, July
10, 2022. IEEE, 2022, pp. 119–124. DOI: 10.1109/ICDCSW56584.2022.00032.
Programming”. In: COORDINATION 2023, Proceedings. Vol. 13908. Lecture Notes in Computer Science.
Springer, 2023, pp. 31–51. DOI: 10.1007/978-3-031-35361-1_2.
[5] G. Aguzzi, R. Casadei, and M. Viroli. “Towards Reinforcement Learning-based Aggregate Computing”. In:
COORDINATION 2022 Proceedings. Vol. 13271. Lecture Notes in Computer Science. Springer, 2022, pp. 72–91.
DOI: 10.1007/978-3-031-08143-9_5.
[6] G. Aguzzi et al. “A field-based computing approach to sensing-driven clustering in robot swarms”. In: Swarm Intell.
17.1-2 (2023), pp. 27–62. DOI: 10.1007/s11721-022-00215-y. URL:
https://doi.org/10.1007/s11721-022-00215-y.
[7] G. Aguzzi et al. “Dynamic Decentralization Domains for the Internet of Things”. In: IEEE Internet Comput. 26.6
(2022), pp. 16–23. DOI: 10.1109/MIC.2022.3216753. URL:
https://doi.org/10.1109/MIC.2022.3216753.
[8] G. Aguzzi et al. “ScaFi-Blocks: A Visual Aggregate Programming Environment for Low-Code Swarm Design”. In:
Coordination Models and Languages - 26th IFIP WG 6.1 International Conference, COORDINATION 2024, Held
as Part of the 19th International Federated Conference on Distributed Computing Techniques, DisCoTec 2024,
Proceedings. Vol. 14676. LNCS. Springer, 2024, pp. 258–276. DOI: 10.1007/978-3-031-62697-5_14.

References (2/10)
[9] G. Aguzzi et al. “ScaFi-Web: A Web-Based Application for Field-Based Coordination Programming”. In:
COORDINATION 2021, , Proceedings. Vol. 12717. Lecture Notes in Computer Science. Springer, 2021,
pp. 285–299. DOI: 10.1007/978-3-030-78142-2_18.
[10] G. Aguzzi et al. “Towards Pulverised Architectures for Collective Adaptive Systems through Multi-Tier
Programming”. In: ACSOS 2021, Companion Volume. IEEE, 2021, pp. 99–104. DOI:
10.1109/ACSOS-C52956.2021.00033.
[11] G. Audrito. “FCPP: an efficient and extensible Field Calculus framework”. In: IEEE International Conference on
Autonomic Computing and Self-Organizing Systems, ACSOS 2020, Washington, DC, USA, August 17-21, 2020.
IEEE, 2020, pp. 153–159. DOI: 10.1109/ACSOS49614.2020.00037.
[12] G. Audrito et al. “A higher-order calculus of computational fields”. In: ACM Transactions on Computational Logic
(TOCL) 20.1 (2019), pp. 1–55.
[13] G. Audrito et al. “Adaptive distributed monitors of spatial properties for cyber-physical systems”. In: J. Syst. Softw.
175 (2021), p. 110908. DOI: 10.1016/j.jss.2021.110908. URL:
https://doi.org/10.1016/j.jss.2021.110908.
[14] G. Audrito et al. “Compositional blocks for optimal self-healing gradients”. In: 2017 IEEE 11th International
Conference on Self-Adaptive and Self-Organizing Systems (SASO). IEEE. 2017, pp. 91–100.
[15] G. Audrito et al. “Computation Against a Neighbour: Addressing Large-Scale Distribution and Adaptivity with
Functional Programming and Scala”. In: Log. Methods Comput. Sci. Volume 19, Issue 1 (Jan. 2023). DOI:
10.46298/lmcs-19(1:6)2023. URL: https://lmcs.episciences.org/10826.
[16] G. Audrito et al. “Distributed Real-Time Shortest-Paths Computations with the Field Calculus”. In: 2018 IEEE
Real-Time Systems Symposium, RTSS 2018, Nashville, TN, USA, December 11-14, 2018. IEEE Computer
Society, 2018, pp. 23–34. DOI: 10.1109/RTSS.2018.00013.
[17] G. Audrito et al. “Field-based Coordination with the Share Operator”. In: Log. Methods Comput. Sci. Volume 16,
Issue 4 (Oct. 2020). URL: https://lmcs.episciences.org/6816.

References (3/10)
[18] G. Audrito et al. “Functional Programming for Distributed Systems with XC”. In: ECOOP 2022. Vol. 222. LIPIcs.
Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2022, 20:1–20:28. DOI: 10.4230/LIPIcs.ECOOP.2022.20.
[19] G. Audrito et al. “Optimal resilient distributed data collection in mobile edge environments”. In: Computers
Electrical Engineering (2021), p. 107580. ISSN: 0045-7906. DOI:
https://doi.org/10.1016/j.compeleceng.2021.107580. URL:
https://www.sciencedirect.com/science/article/pii/S0045790621005140.
[20] G. Audrito et al. “Programming Distributed Collective Processes for Dynamic Ensembles and Collective Tasks”. In:
Coordination Models and Languages - 25th IFIP WG 6.1 International Conference, COORDINATION 2023, Held
as Part of the 18th International Federated Conference on Distributed Computing Techniques, DisCoTec 2023,
Lisbon, Portugal, June 19-23, 2023, Proceedings. Ed. by S. Jongmans and A. Lopes. Vol. 13908. Lecture Notes in
Computer Science. Springer, 2023, pp. 71–89. DOI: 10.1007/978-3-031-35361-1_4. URL:
https://doi.org/10.1007/978-3-031-35361-1_4.
[21] G. Audrito et al. “Space-Time Universality of Field Calculus”. In: COORDINATION 2018, Proceedings. Vol. 10852.
Lecture Notes in Computer Science. Springer, 2018, pp. 1–20. DOI: 10.1007/978-3-319-92408-3_1.
[22] G. Audrito et al. “The eXchange Calculus (XC): A functional programming language design for distributed
collective systems”. In: Journal of Systems and Software (2024), p. 111976. ISSN: 0164-1212. DOI:
https://doi.org/10.1016/j.jss.2024.111976.
[23] J. Beal, D. Pianini, and M. Viroli. “Aggregate programming for the internet of things”. In: Computer 48.9 (2015),
pp. 22–30.
[24] J. Beal et al. “Organizing the Aggregate: Languages for Spatial Computing”. In: CoRR abs/1202.5509 (2012).
[25] J. Beal et al. “Self-Adaptation to Device Distribution in the Internet of Things”. In: ACM Trans. Auton. Adapt. Syst.
12.3 (2017), 12:1–12:29. DOI: 10.1145/3105758. URL: https://doi.org/10.1145/3105758.
[26] M. Birattari, A. Ligot, and G. Francesca. “AutoMoDe: A Modular Approach to the Automatic Off-Line Design and
Fine-Tuning of Control Software for Robot Swarms”. In: Automated Design of Machine Learning and Search
Algorithms. Natural Computing Series. Springer, 2021, pp. 73–90. DOI: 10.1007/978-3-030-72069-8_5.

References (4/10)
[27] O. Boissier et al. Multi-agent oriented programming: programming multi-agent systems using JaCaMo. Mit Press,
2020.
[28] M. Brambilla et al. “Swarm robotics: a review from the swarm engineering perspective”. In: Swarm Intell. 7.1
(2013), pp. 1–41. DOI: 10.1007/S11721-012-0075-2.
[29] A. Bucchiarone et al. “On the Social Implications of Collective Adaptive Systems”. In: IEEE Technol. Soc. Mag.
39.3 (2020), pp. 36–46. DOI: 10.1109/MTS.2020.3012324.
(2023), pp. 1–35. ISSN: 1064-5462. DOI: 10.1162/artl_a_00408. URL:
https://doi.org/10.1162/artl_a_00408.
[31] R. Casadei. “Macroprogramming: Concepts, State of the Art, and Opportunities of Macroscopic Behaviour
Modelling”. In: ACM Comput. Surv. 55.13s (2023). ISSN: 0360-0300. DOI: 10.1145/3579353.
Internet of Things (Dec. 2024), p. 101436. ISSN: 2542-6605. DOI: 10.1016/j.iot.2024.101436.
[33] R. Casadei, G. Aguzzi, and M. Viroli. “A Programming Approach to Collective Autonomy”. In: J. Sens. Actuator
Networks 10.2 (2021), p. 27. DOI: 10.3390/jsan10020027.
[34] R. Casadei, A. Aldini, and M. Viroli. “Towards attack-resistant aggregate computing using trust mechanisms”. In:
Science of Computer Programming 167 (2018), pp. 114–137.
[35] R. Casadei and M. Viroli. “Coordinating Computation at the Edge: a Decentralized, Self-Organizing, Spatial
Approach”. In: FMEC. IEEE, 2019, pp. 60–67.
[36] R. Casadei and M. Viroli. “Declarative Macro-Programming of Collective Systems with Aggregate Computing: An
Experience Report”. In: Proceedings of the 26th International Symposium on Principles and Practice of
Declarative Programming. PPDP’24. Milano, Italy: ACM, 2024. ISBN: 9798400709692. DOI:
10.1145/3678232.3678235.

References (5/10)
[37] R. Casadei and M. Viroli. “Programming actor-based collective adaptive systems”. In: Programming with Actors.
Springer, 2018, pp. 94–122.
[38] R. Casadei and M. Viroli. “Towards Aggregate Programming in Scala”. In: First Workshop on Programming
Models and Languages for Distributed Computing, PMLDC@ECOOP 2016, Rome, Italy, July 17, 2016. ACM,
2016, p. 5. DOI: 10.1145/2957319.2957372. URL: https://doi.org/10.1145/2957319.2957372.
[39] R. Casadei, M. Viroli, and A. Ricci. “Collective Adaptive Systems as Coordination Media: The Case of Tuples in
Space-Time”. In: ACSOS Companion. IEEE, 2020, pp. 139–144.
[40] R. Casadei et al. “A development approach for collective opportunistic Edge-of-Things services”. In: Inf. Sci. 498
(2019), pp. 154–169. DOI: 10.1016/j.ins.2019.05.058.
[41] R. Casadei et al. “A development approach for collective opportunistic Edge-of-Things services”. In: Inf. Sci. 498
(2019), pp. 154–169. DOI: 10.1016/j.ins.2019.05.058.
[42] R. Casadei et al. “A Methodology and Simulation-based Toolchain for Estimating Deployment Performance of
Smart Collective Services at the Edge”. In: IEEE Internet Things J. (2022), pp. 1–1. DOI:
10.1109/JIOT.2022.3172470.
[43] R. Casadei et al. “Aggregate Processes in Field Calculus”. In: COORDINATION. Vol. 11533. Lecture Notes in
Computer Science. Springer, 2019, pp. 200–217.
[44] R. Casadei et al. “Digital Twins, Virtual Devices, and Augmentations for Self-Organising Cyber-Physical
Collectives”. In: Applied Sciences 12.1 (Dec. 2021), p. 349. DOI: 10.3390/app12010349.
[45] R. Casadei et al. “Engineering collective intelligence at the edge with aggregate processes”. In: Engineering
Applications of Artificial Intelligence 97 (2020), p. 104081.
[46] R. Casadei et al. “Engineering Resilient Collaborative Edge-Enabled IoT”. In: SCC. IEEE, 2019, pp. 36–45.

References (6/10)
[47] R. Casadei et al. “FScaFi : A Core Calculus for Collective Adaptive Systems Programming”. In: Leveraging
Applications of Formal Methods, Verification and Validation: Engineering Principles - 9th International Symposium
on Leveraging Applications of Formal Methods, ISoLA 2020, Proceedings, Part II. Vol. 12477. Lecture Notes in
Computer Science. Springer, 2020, pp. 344–360. DOI: 10.1007/978-3-030-61470-6_21.
[48] R. Casadei et al. “Modelling and simulation of opportunistic IoT services with aggregate computing”. In: Future
Generation Computer Systems 91 (2019), pp. 252–262. DOI: 10.1016/j.future.2018.09.005.
[49] R. Casadei et al. “Modelling Groups of Humans: Towards Crowd Digital Twins”. In: 2024 IEEE Symposium on
Computers and Communications (ISCC). IEEE, June 2024, 1–6. DOI: 10.1109/iscc61673.2024.10733562.
[50] R. Casadei et al. “On Context-Orientation in Aggregate Programming”. In: FAS*W@SASO/ICAC. IEEE, 2019,
pp. 92–97.
[51] R. Casadei et al. “Programming IoT systems: A focused conceptual framework and survey of approaches”. In:
Internet of Things (Feb. 2025), p. 101548. ISSN: 2542-6605. DOI: 10.1016/j.iot.2025.101548.
[52] R. Casadei et al. “Pulverization in Cyber-Physical Systems: Engineering the Self-Organizing Logic Separated
from Deployment”. In: Future Internet 12.11 (2020), p. 203.
[53] R. Casadei et al. “ScaFi: A Scala DSL and Toolkit for Aggregate Programming”. In: SoftwareX 20 (2022),
p. 101248. DOI: 10.1016/j.softx.2022.101248. URL:
https://doi.org/10.1016/j.softx.2022.101248.
[54] R. Casadei et al. “Self-Organisation Programming: A Functional Reactive Macro Approach”. In: ACSOS 2023.
IEEE, 2023. DOI: 10.1109/ACSOS58161.2023.00026.
[55] R. Casadei et al. “Self-organising Coordination Regions: A Pattern for Edge Computing”. In: COORDINATION
2019, Proceedings. Vol. 11533. Lecture Notes in Computer Science. Springer, 2019, pp. 182–199. DOI:
10.1007/978-3-030-22397-7_11.
[56] R. Casadei et al. “Software Engineering for Collective Cyber-Physical Ecosystems”. In: ACM Trans. Softw. Eng.
Methodol. (2025). ISSN: 1557-7392. DOI: 10.1145/3712004.

References (7/10)
[57] R. Casadei et al. “Space-Fluid Adaptive Sampling: A Field-Based, Self-organising Approach”. In:
COORDINATION 2022, Proceedings. Vol. 13271. Lecture Notes in Computer Science. Springer, 2022,
pp. 99–117. DOI: 10.1007/978-3-031-08143-9_7.
[58] R. Casadei et al. “Space-Fluid Adaptive Sampling by Self-Organisation”. In: Logical Methods in Computer
Science Volume 19, Issue 4 (Dec. 2023). ISSN: 1860-5974. DOI: 10.46298/lmcs-19(4:29)2023.
[59] R. Casadei et al. “Tuple-Based Coordination in Large-Scale Situated Systems”. In: COORDINATION 2021,
Proceedings. Vol. 12717. LNCS. Springer, 2021, pp. 149–167. DOI: 10.1007/978-3-030-78142-2_10.
[60] A. Corbetta and F. Toschi. “Physics of Human Crowds”. In: Annu. Rev. Condens. Matter Phys. 14.1 (2023),
311–333. ISSN: 1947-5462. DOI: 10.1146/annurev-conmatphys-031620-100450. URL:
http://dx.doi.org/10.1146/annurev-conmatphys-031620-100450.
[61] A. Cortecchia et al. “An Aggregate Vascular Morphogenesis Controller for Engineered Self-Organising Spatial
Structures”. In: IEEE International Conference on Autonomic Computing and Self-Organizing Systems, ACSOS
2024, Aarhus, Denmark, Sep 16-20, 2024. IEEE, 2024, pp. 133–138. DOI:
10.1109/ACSOS61780.2024.00032.
[62] L. Cruz-Filipe, F. Montesi, and M. Peressotti. “A Formal Theory of Choreographic Programming”. In: J. Autom.
Reason. 67.2 (2023), p. 21. DOI: 10.1007/S10817-023-09665-3.
[63] N. Farabegoli, M. Viroli, and R. Casadei. “Flexible Self-organisation for the Cloud-Edge Continuum: a
Macro-programming Approach”. In: IEEE International Conference on Autonomic Computing and Self-Organizing
Systems, ACSOS 2024, Aarhus, Denmark, Sep 16-20, 2024. IEEE, 2024, pp. 21–30. DOI:
10.1109/ACSOS61780.2024.00020.
[64] N. Farabegoli et al. “Dynamic IoT deployment reconfiguration: A global-level self-organisation approach”. In:
Internet of Things 28 (Dec. 2024), p. 101412. ISSN: 2542-6605. DOI: 10.1016/j.iot.2024.101412.
[65] N. Farabegoli et al. “Scalability through Pulverisation: Declarative deployment reconfiguration at runtime”. In:
Future Generation Computer Systems 161 (Dec. 2024), 545–558. ISSN: 0167-739X. DOI:
10.1016/j.future.2024.07.042.

References (8/10)
[66] F. He et al. “Collective Intelligence: A Taxonomy and Survey”. In: IEEE Access 7 (2019), pp. 170213–170225. DOI:
10.1109/ACCESS.2019.2955677. URL: https://doi.org/10.1109/ACCESS.2019.2955677.
[67] M. Mamei, F. Zambonelli, and L. Leonardi. “Co-Fields: A Physically Inspired Approach to Motion Coordination”. In:
IEEE Pervasive Computing 3.2 (2004), pp. 52–61. DOI: 10.1109/MPRV.2004.1316820.
[68] S. Mariani et al. “Case Studies for a New IoT Programming Paradigm: Fluidware”. In: AIIoT@AI*IA. Vol. 2502.
CEUR Workshop Proceedings. CEUR-WS.org, 2019, pp. 82–96.
[69] C. Masolo et al. “Pluralities, Collectives, and Composites”. In: Formal Ontology in Information Systems -
Proceedings of the 11th International Conference, FOIS 2020. Vol. 330. Frontiers in Artificial Intelligence and
Applications. IOS Press, 2020, pp. 186–200. DOI: 10.3233/FAIA200671.
[70] Y. Mo, J. Beal, and S. Dasgupta. “An aggregate computing approach to self-stabilizing leader election”. In: 2018
IEEE 3rd International Workshops on Foundations and Applications of Self* Systems (FAS* W). IEEE. 2018,
pp. 112–117.
[71] R. D. Nicola, S. Jähnichen, and M. Wirsing. “Rigorous engineering of collective adaptive systems: special section”.
In: Int. J. Softw. Tools Technol. Transf. 22.4 (2020), pp. 389–397. DOI: 10.1007/s10009-020-00565-0. URL:
https://doi.org/10.1007/s10009-020-00565-0.
[72] R. D. Nicola, A. Maggi, and J. Sifakis. “The DReAM framework for dynamic reconfigurable architecture modelling:
theory and applications”. In: Int. J. Softw. Tools Technol. Transf. 22.4 (2020), pp. 437–455. DOI:
10.1007/S10009-020-00555-2.
[73] D. Pianini. “Simulation of Large Scale Computational Ecosystems with Alchemist: A Tutorial”. In: DAIS 2021,
Proceedings. Vol. 12718. Lecture Notes in Computer Science. Springer, 2021, pp. 145–161. DOI:
10.1007/978-3-030-78198-9_10. URL: https://doi.org/10.1007/978-3-030-78198-9_10.
[74] D. Pianini, R. Casadei, and M. Viroli. “Self-stabilising Priority-Based Multi-Leader Election and Network
Partitioning”. In: IEEE International Conference on Autonomic Computing and Self-Organizing Systems, ACSOS
2022. IEEE, 2022, pp. 81–90. DOI: 10.1109/ACSOS55765.2022.00026. URL:
https://doi.org/10.1109/ACSOS55765.2022.00026.

References (9/10)
[75] D. Pianini, S. Dobson, and M. Viroli. “Self-stabilising target counting in wireless sensor networks using euler
integration”. In: 2017 IEEE 11th International Conference on Self-Adaptive and Self-Organizing Systems (SASO).
IEEE. 2017, pp. 11–20.
[76] D. Pianini, S. Montagna, and M. Viroli. “Chemical-oriented simulation of computational systems with ALCHEMIST”.
In: J. Simulation 7.3 (2013), pp. 202–215. DOI: 10.1057/jos.2012.27. URL:
https://doi.org/10.1057/jos.2012.27.
[77] D. Pianini, M. Viroli, and J. Beal. “Protelis: practical aggregate programming”. In: Proceedings of the 30th Annual
ACM Symposium on Applied Computing, Salamanca, Spain, April 13-17, 2015. ACM, 2015, pp. 1846–1853. DOI:
10.1145/2695664.2695913.
[78] D. Pianini et al. “A Collective Adaptive Approach to Decentralised k-Coverage in Multi-robot Systems”. In: ACM
Trans. Auton. Adapt. Syst. 17 (2022), 4:1–4:39. DOI: 10.1145/3547145. URL:
https://doi.org/10.1145/3547145.
[79] D. Pianini et al. “Partitioned integration and coordination via the self-organising coordination regions pattern”. In:
Future Gener. Comput. Syst. 114 (2021), pp. 44–68.
[80] D. Pianini et al. “Time-Fluid Field-Based Coordination through Programmable Distributed Schedulers”. In: Log.
Methods Comput. Sci. Volume 17, Issue 4 (Nov. 2021). DOI: 10.46298/lmcs-17(4:13)2021. URL:
https://lmcs.episciences.org/8755.
[81] A. Ricci et al. “Spatial Tuples: Augmenting reality with tuples”. In: Expert Syst. J. Knowl. Eng. 35.5 (2018). DOI:
10.1111/exsy.12273.
[82] F. E. Rosas et al. “Software in the natural world: A computational approach to hierarchical emergence”. In: (2024).
DOI: 10.48550/ARXIV.2402.09090. arXiv: 2402.09090. URL: https://arxiv.org/abs/2402.09090.
[83] L. Serena et al. “A review of multilevel modeling and simulation for human mobility and behavior”. In: Simulation
Modelling Practice and Theory 127 (Sept. 2023), p. 102780. ISSN: 1569-190X. DOI:
10.1016/j.simpat.2023.102780. URL: http://dx.doi.org/10.1016/j.simpat.2023.102780.

References (10/10)
[84] M. Viroli et al. “Aggregate plans for multiagent systems”. In: International Journal of Agent-Oriented Software
Engineering 5.4 (2017), pp. 336–365.
[85] M. Viroli et al. “Engineering resilient collective adaptive systems by self-stabilisation”. In: ACM Transactions on
Modeling and Computer Simulation (TOMACS) 28.2 (2018), pp. 1–28.
[86] M. Viroli et al. “From distributed coordination to field calculus and aggregate computing”. In: J. Log. Algebraic
Methods Program. 109 (2019).
[87] C. W. Warren. “Multiple robot path coordination using artificial potential fields”. In: Proceedings., IEEE
International Conference on Robotics and Automation. IEEE. 1990, pp. 500–505.
[88] P. Weisenburger, J. Wirth, and G. Salvaneschi. “A Survey of Multitier Programming”. In: ACM Comput. Surv. 53.4
(2021), 81:1–81:35. DOI: 10.1145/3397495.

Some relevant publications
1. [56]: R. Casadei, G. Aguzzi, G. Audrito, F. Damiani, D. Pianini, G. Scarso, G. Torta, and M. Viroli. “Software
2. [32]: R. Casadei. “System-Wide IoT design and programming: Patterns for decentralised collective processes”. In:
3. [31]: R. Casadei. “Macroprogramming: Concepts, State of the Art, and Opportunities of Macroscopic Behaviour
Modelling”. In: ACM Comput. Surv. 13s (2023)
4. [30]: R. Casadei. “Artificial Collective Intelligence Engineering: A Survey of Concepts and Perspectives”. In: Artif.
Life (2023)
5. [22]: G. Audrito, R. Casadei, F. Damiani, G. Salvaneschi, and M. Viroli. “The eXchange Calculus (XC): A functional
programming language design for distributed collective systems”. In: Journal of Systems and Software (2024)
6. [13]: G. Audrito, R. Casadei, F. Damiani, V. Stolz, and M. Viroli. “Adaptive distributed monitors of spatial properties
for cyber-physical systems”. In: J. Syst. Softw. (2021)
7. [45]: R. Casadei, M. Viroli, G. Audrito, D. Pianini, and F. Damiani. “Engineering collective intelligence at the edge
with aggregate processes”. In: Engineering Applications of Artificial Intelligence (2020)
8. [86]: M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini. “From distributed coordination to field
R. Casadei 72/71

A classification of research contributions
1. Programming languages for self-organising and collective adaptive systems (also including
swarms and IoT systems)
∠ perspectives and paradigms: macroprogramming [31, 86]
∠ DSLs: ScaFi [53], FRASP [54]
∠ core languages (inspired by field calculi): Neighbours Calculus [15], eXchange Calculus [18]
∠ abstractions: collective processes [45, 20]
∠ APIs: distributed sensing action [7], spatiotemporal tuples [59], MacroSwarm [4]
2. Distributed algorithms and learning
∠ distributed collection [19], self-stabilising leader election [74], gradients [14]
∠ reinforcement learning for synthesis of programs [5] and execution strategies [2]
3. IoT–edge–cloud ecosystems
∠ patterns: Self-organising Coordination Regions [79, 35]
∠ partitioning deployment models: Pulverisation [52, 42, 10]
∠ application models: opportunistic collective services [48, 41]
4. Applications
∠ distributed sensing [19], sensing-driven clustering [6, 57]
∠ object coverage by smartcam networks [78]
∠ distributed monitors of spatial properties [13]
5. Broad topics: collective intelligence [30], social implications of CASs [29]
R. Casadei 73/71

Collaborations with Research Groups
ITA (UNIBO): Prof. Mirko Viroli, Dr. Danilo Pianini, Dr. Gianluca Aguzzi
∠ main research group
ITA (UNITO): Prof. Ferruccio Damiani, Dr. Giorgio Audrito [15, 18, 19, 13]
∠ main collaborators (experts on formal methods)
ITA (UNICAL): Prof. Giancarlo Fortino, Dr. Claudio Savaglio [42, 41, 48, 45, 86]
∠ cf. PRIN Project COMMON-WEARS: COMMunity-OrieNted WEARable Computing Systems (+
UNIBZ + UNICAMPUS)
ITA (UNIMORE): Prof. Franco Zambonelli, Dr. Stefano Mariani [57, 80]
∠ cf. PRIN Project FluidWare: A novel paradigm for Large-Scale IoT Systems (+ UNICAM)
AUT (TU Wien): Prof. Schahram Dustdar [46]
∠ visit during PhD; worked on IoT/Edge
SCT (St Andrews University): Prof. Simon Dobson [29]
∠ cf. ACSOS community + visit during PhD
ITA (FBK Trento): Prof. Antonio Bucchiarone [29] (cf. ACSOS community)
ITA (UNIURB): Prof. Alessandro Aldini [34] (AC + trust)
BEL (University of Leuven): Prof. Danny Weyns [52, 44] (cf. ACSOS / SEAMS comm.)
DK (Aarhus University): Prof. Lukas Esterle [78] (cf. ACSOS community)
CH (St Gallen University): Prof. Guido Salvaneschi [18, 10] (cf. ECOOP community)
USA (Raytheon/BBN): Prof. Jacob Beal [86] (cf. aggregate computing)
R. Casadei 74/71

ScaFi-Blocks: Low-code aggregate programming [8]
[8] G. Aguzzi, R. Casadei, M. Cerioni, and M. Viroli. “ScaFi-Blocks: A Visual Aggregate Programming Environment for
Low-Code Swarm Design”. In: Coordination Models and Languages - 26th IFIP WG 6.1 International Conference,
COORDINATION 2024, Held as Part of the 19th International Federated Conference on Distributed Computing
Techniques, DisCoTec 2024, Proceedings. LNCS. Springer, 2024
R. Casadei 75/71

Software Engineering Methods for Artificial Collective Intelligence

More Related Content

Similar to Software Engineering Methods for Artificial Collective Intelligence

More from Roberto Casadei

Recently uploaded

Software Engineering Methods for Artificial Collective Intelligence