The document describes a Functional Reactive Approach to Self-Organisation Programming (FRASP). FRASP interprets the aggregate programming model from a functional reactive programming (FRP) perspective and implements it as a Scala DSL. It provides reactive abstractions like Flow to express distributed, time-varying computations. Examples demonstrate how FRASP can declaratively define self-organizing behaviors like gradient fields and self-healing channels through reactive compositions of local computations.
Programming Distributed Collective Processes for Dynamic Ensembles and Collec...Roberto Casadei
Recent trends like the Internet of Things (IoT) suggest a vi-
sion of dense and multi-scale deployments of computing devices in nearly
all kinds of environments. A prominent engineering challenge revolves
around programming the collective adaptive behaviour of such compu-
tational ecosystems. This requires abstractions able to capture concepts
like ensembles (dynamic groups of cooperating devices) and collective
tasks (joint activities carried out by ensembles). In this work, we con-
sider collections of devices interacting with neighbours and that execute
in nearly-synchronised sense–compute–interact rounds, where the com-
putation is given by a single control program. To support programming
whole computational collectives, we propose the abstraction of a dis-
tributed collective process (DCP), which can be used to define at once
the ensemble formation logic and its collective task. We implement the
abstraction in the eXchange Calculus (XC), a core language based on
neighbouring values (maps from neighbours to values) where state man-
agement and interaction is handled through a single primitive, exchange.
Then, we discuss the features of the abstraction, its suitability for differ-
ent kinds of distributed computing applications, and provide a proof-of-
concept implementation of a wave-like process propagation.
Towards Automated Engineering for Collective Adaptive Systems: Vision and Res...Roberto Casadei
The opportunities and challenges of recent and
forthcoming distributed computing scenarios have been promot-
ing research on languages and paradigms aimed at modelling the
macro/collective behaviour of systems as well as mechanisms to
endow them with self-* capabilities. One example is the aggregate
computing paradigm, which supports the development of self-
organising systems (e.g., robot swarms, computational ecosys-
tems, and crowd-based services) through various formalisms and
tools developed over a decade. However, very limited work has
been done by a methodological and automation perspective. In
this paper, we explore the issue of organising the development
process of aggregate computing systems. Accordingly, we outline
novel research directions that arise from careful analysis of
the peculiar issues in collective and self-organising systems, the
cornerstones of effective software engineering practices, and
recent scientific trends and insights.
Aggregate computing is a research topic that is addressed by multiple perspectives: computational models, programming languages, distributed adaptive algorithms, middleware architectures, formal analysis, tools.
Digital Twins, Virtual Devices, and Augmentations for Self-Organising Cyber-P...Roberto Casadei
The engineering of large-scale cyber-physical systems (CPS) increasingly relies on principles from self-organisation and collective computing, enabling these systems to cooperate and adapt in dynamic environments. CPS engineering also often leverages digital twins that provide synchronised logical counterparts of physical entities. In contrast, sensor networks rely on the different but related concept of virtual device that provides an abstraction of a group of sensors. In this work, we study how such concepts can contribute to the engineering of self-organising CPSs. To that end, we analyse the concepts and devise modelling constructs, distinguishing between identity correspondence and execution relationships. Based on this analysis, we then contribute to the novel concept of “collective digital twin” (CDT) that captures the logical counterpart of a collection of physical devices. A CDT can also be “augmented” with purely virtual devices, which may be exploited to steer the self-organisation process of the CDT and its physical counterpart. We underpin the novel concept with experiments in the context of the pulverisation framework of aggregate computing, showing how augmented CDTs provide a holistic, modular, and cyber-physically integrated system view that can foster the engineering of self-organising CPSs.
Collective Adaptive Systems as Coordination Media: The Case of Tuples in Spac...Roberto Casadei
Coordination is a fundamental problem in the
engineering of collective adaptive systems (CAS). Prominent
approaches in this context promote adaptivity and collective
behaviour by founding coordination on local, decentralised in-
teraction. This is usually enabled through abstractions such as
collective interfaces, neighbour-based interaction, and attribute-
based communication. Application designers, then, use such
coordination mechanisms to enact collective adaptive behaviour
in order to solve specific problems or provide specific services
while coping with dynamic environments. In this paper, we
consider the other way round: we argue that a CAS model can
be used to provide support for high-level coordination models,
simplifying their implementation and transferring to them the
self-* properties it emergently fosters. As a motivating example,
we consider the idea of supporting tuple-based coordination by
Linda primitives such that tuples and operations have a position
and extension in space and time. Then, we adopt an aggregate
perspective, by which space-time is logically represented by a
mobile ad-hoc network of devices, and show that coordination
primitives can be implemented as true collective adaptive pro-
cesses. We describe this model and a prototype implementation
in the ScaFi aggregate programming framework, which is rooted
in the so-called computational field paradigm.
FScaFi: A Core Calculus for Collective Adaptive Systems ProgrammingRoberto Casadei
A recently proposed approach to the rigorous engineering of collective adaptive systems is the aggregate computing paradigm, which operationalises the idea of expressing collective adaptive behaviour by a global perspective as a functional composition of dynamic computational fields (i.e., structures mapping a collection of individual devices of a collective to computational values over time). In this paper, we present FScaFi, a core language that captures the essence of exploiting field computations in mainstream functional languages, and which is based on a semantic model for field computations leveraging the novel notion of “computation against a neighbour”. Such a construct models expressions whose evaluation depends on the same evaluation that occurred on a neighbour, thus abstracting communication actions and, crucially, enabling deep and straightforward integration in the Scala programming language, by the ScaFi incarnation. We cover syntax and informal semantics of FScaFi, provide examples of collective adaptive behaviour development in ScaFi, and delineate future work.
In recent years, we are witnessing a growing interest in large-scale situated systems, such as those falling under the umbrella of pervasive computing, cyber-physical systems, and the Internet of Things. The actor model is a natural choice for designing and implementing such systems, thanks to the ability of actors to address distribution, autonomy of control, and asynchronous communication: namely, it is convenient to view the pervasive cyberspace as an environment densely inhabited by mobile embedded actors. But how can an actor-centric development approach be fruitfully used to engineer a complex coordination strategy, where a myriad of devices/actors performs adaptive distributed sensing/processing/acting?
Aggregate computing has been proposed as an emerging paradigm that faces this general problem by adopting a global, system-level stance, allowing to specify and functionally compose collective behaviours by operating on diffused data structures, known as “computational fields”. In this paper, we develop on the idea of integrating the actor model and aggregate computing, presenting a software framework where declarative global-level system specifications are automatically turned into an underlying system of Scala/Akka actors carrying on computation over the pervasive computing system.
Programming Distributed Collective Processes for Dynamic Ensembles and Collec...Roberto Casadei
Recent trends like the Internet of Things (IoT) suggest a vi-
sion of dense and multi-scale deployments of computing devices in nearly
all kinds of environments. A prominent engineering challenge revolves
around programming the collective adaptive behaviour of such compu-
tational ecosystems. This requires abstractions able to capture concepts
like ensembles (dynamic groups of cooperating devices) and collective
tasks (joint activities carried out by ensembles). In this work, we con-
sider collections of devices interacting with neighbours and that execute
in nearly-synchronised sense–compute–interact rounds, where the com-
putation is given by a single control program. To support programming
whole computational collectives, we propose the abstraction of a dis-
tributed collective process (DCP), which can be used to define at once
the ensemble formation logic and its collective task. We implement the
abstraction in the eXchange Calculus (XC), a core language based on
neighbouring values (maps from neighbours to values) where state man-
agement and interaction is handled through a single primitive, exchange.
Then, we discuss the features of the abstraction, its suitability for differ-
ent kinds of distributed computing applications, and provide a proof-of-
concept implementation of a wave-like process propagation.
Towards Automated Engineering for Collective Adaptive Systems: Vision and Res...Roberto Casadei
The opportunities and challenges of recent and
forthcoming distributed computing scenarios have been promot-
ing research on languages and paradigms aimed at modelling the
macro/collective behaviour of systems as well as mechanisms to
endow them with self-* capabilities. One example is the aggregate
computing paradigm, which supports the development of self-
organising systems (e.g., robot swarms, computational ecosys-
tems, and crowd-based services) through various formalisms and
tools developed over a decade. However, very limited work has
been done by a methodological and automation perspective. In
this paper, we explore the issue of organising the development
process of aggregate computing systems. Accordingly, we outline
novel research directions that arise from careful analysis of
the peculiar issues in collective and self-organising systems, the
cornerstones of effective software engineering practices, and
recent scientific trends and insights.
Aggregate computing is a research topic that is addressed by multiple perspectives: computational models, programming languages, distributed adaptive algorithms, middleware architectures, formal analysis, tools.
Digital Twins, Virtual Devices, and Augmentations for Self-Organising Cyber-P...Roberto Casadei
The engineering of large-scale cyber-physical systems (CPS) increasingly relies on principles from self-organisation and collective computing, enabling these systems to cooperate and adapt in dynamic environments. CPS engineering also often leverages digital twins that provide synchronised logical counterparts of physical entities. In contrast, sensor networks rely on the different but related concept of virtual device that provides an abstraction of a group of sensors. In this work, we study how such concepts can contribute to the engineering of self-organising CPSs. To that end, we analyse the concepts and devise modelling constructs, distinguishing between identity correspondence and execution relationships. Based on this analysis, we then contribute to the novel concept of “collective digital twin” (CDT) that captures the logical counterpart of a collection of physical devices. A CDT can also be “augmented” with purely virtual devices, which may be exploited to steer the self-organisation process of the CDT and its physical counterpart. We underpin the novel concept with experiments in the context of the pulverisation framework of aggregate computing, showing how augmented CDTs provide a holistic, modular, and cyber-physically integrated system view that can foster the engineering of self-organising CPSs.
Collective Adaptive Systems as Coordination Media: The Case of Tuples in Spac...Roberto Casadei
Coordination is a fundamental problem in the
engineering of collective adaptive systems (CAS). Prominent
approaches in this context promote adaptivity and collective
behaviour by founding coordination on local, decentralised in-
teraction. This is usually enabled through abstractions such as
collective interfaces, neighbour-based interaction, and attribute-
based communication. Application designers, then, use such
coordination mechanisms to enact collective adaptive behaviour
in order to solve specific problems or provide specific services
while coping with dynamic environments. In this paper, we
consider the other way round: we argue that a CAS model can
be used to provide support for high-level coordination models,
simplifying their implementation and transferring to them the
self-* properties it emergently fosters. As a motivating example,
we consider the idea of supporting tuple-based coordination by
Linda primitives such that tuples and operations have a position
and extension in space and time. Then, we adopt an aggregate
perspective, by which space-time is logically represented by a
mobile ad-hoc network of devices, and show that coordination
primitives can be implemented as true collective adaptive pro-
cesses. We describe this model and a prototype implementation
in the ScaFi aggregate programming framework, which is rooted
in the so-called computational field paradigm.
FScaFi: A Core Calculus for Collective Adaptive Systems ProgrammingRoberto Casadei
A recently proposed approach to the rigorous engineering of collective adaptive systems is the aggregate computing paradigm, which operationalises the idea of expressing collective adaptive behaviour by a global perspective as a functional composition of dynamic computational fields (i.e., structures mapping a collection of individual devices of a collective to computational values over time). In this paper, we present FScaFi, a core language that captures the essence of exploiting field computations in mainstream functional languages, and which is based on a semantic model for field computations leveraging the novel notion of “computation against a neighbour”. Such a construct models expressions whose evaluation depends on the same evaluation that occurred on a neighbour, thus abstracting communication actions and, crucially, enabling deep and straightforward integration in the Scala programming language, by the ScaFi incarnation. We cover syntax and informal semantics of FScaFi, provide examples of collective adaptive behaviour development in ScaFi, and delineate future work.
In recent years, we are witnessing a growing interest in large-scale situated systems, such as those falling under the umbrella of pervasive computing, cyber-physical systems, and the Internet of Things. The actor model is a natural choice for designing and implementing such systems, thanks to the ability of actors to address distribution, autonomy of control, and asynchronous communication: namely, it is convenient to view the pervasive cyberspace as an environment densely inhabited by mobile embedded actors. But how can an actor-centric development approach be fruitfully used to engineer a complex coordination strategy, where a myriad of devices/actors performs adaptive distributed sensing/processing/acting?
Aggregate computing has been proposed as an emerging paradigm that faces this general problem by adopting a global, system-level stance, allowing to specify and functionally compose collective behaviours by operating on diffused data structures, known as “computational fields”. In this paper, we develop on the idea of integrating the actor model and aggregate computing, presenting a software framework where declarative global-level system specifications are automatically turned into an underlying system of Scala/Akka actors carrying on computation over the pervasive computing system.
Aggregate programming is a novel paradigm that addresses, at the core, many issues commonly found in the development of large-scale, situated, self-adaptive systems. It is a particular macro-programming approach where a developer expresses the behaviour of the system at the aggregate-level, by targeting the distributed computational machine which is given by the entire set of (possibly mobile and heterogeneous) networked devices pervading the environment. It is the model that takes care of turning a system-level behaviour specification into the concrete, device-centric programs executed locally by each component.
Aggregate computing is formally grounded in the field calculus, a minimal functional language that works with computational fields, i.e., distributed data structures mapping devices (digital representatives of space-time portions) to computational objects. Fields are a useful unifying abstraction for drawing a connection between the physical and the computational world, and between the local and global programming viewpoints. This approach is compositional, allowing to define layers of building blocks of increasing abstraction, and is also amenable to formal analyses.
In this talk, I will present scafi (SCAla with computational FIels), an aggregate computing framework for the Scala programming language which provides (i) an internal DSL for expressing aggregate computations as well as (ii) a library support for the configuration and execution of aggregate systems. There is no need to learn ad-hoc external DSLs anymore: with scafi, Scala programmers can instantaneously start playing with this new, intriguing development approach!
Augmented Collective Digital Twins for Self-Organising Cyber-Physical SystemsRoberto Casadei
Context. Self-organising and collective computing
approaches are increasingly applied to large-scale cyber-physical
systems (CPS), enabling them to adapt and cooperate in dynamic
environments. Also, in CPS engineering, digital twins are often
leveraged to provide synchronised logical counterparts of physical
entities, whereas in sensor networks the different-but-related
concept of virtual device is used e.g. to abstract groups of sensors.
Vision. We envision the design concept of “augmented collective
digital twin” that captures digital twins at a collective level
extended with purely virtual devices. We argue that this concept
can foster the engineering of self-organising CPS by providing a
holistic, declarative, and integrated system view.
Method. From a review and proposed taxonomy of logical
devices comprehending both digital twins and virtual devices,
we reinterpret a meta-model for self-organising CPSs and discuss
how it can support augmented collective digital twins. We illus-
trate the approach in a crowd-aware navigation scenario, where
virtual devices are opportunistically integrated into the system
to enhance spatial coverage, improving navigation capabilities.
Conclusion. By integrating physical and virtual devices, the
novel notion of augmented collective digital twin paves the way
to self-improving system functionality and intelligent use of
resources in self-organising CPSs.
On Execution Platforms for Large-Scale Aggregate ComputingRoberto Casadei
Aggregate computing is proposed as a computational model and associated toolchain to engineer adaptive large-scale situated systems, including IoT and wearable computing systems. Though originated in the context of WSN-like (peer-to-peer and fully distributed) systems, we argue it is a model that can transparently fit a variety of execution platforms (decentralised, server-mediated, cloud/fog-oriented), due to its ability of declaratively designing systems by global-level abstractions: it opens the possibility of intrinsically supporting forms of load balancing, elasticity and toleration of medium- and long-term changes of computational infrastructures. To ground the discussion, we present ongoing work in the context of scafi, a language and platform support for computational fields based on the Scala programming language and Akka actor framework.
Coordinating Computation at the Edge: a Decentralized, Self-organizing, Spati...Roberto Casadei
Presentation of a paper accepted at the 4th Internetional Conference on Fog and Mobile Edge Computing (FMEC).
It discusses a decentralised, self-organising, spatial, collective approach to the development of edge-clouds/edge computing ecosystems.
Tuple-Based Coordination in Large-Scale Situated SystemsRoberto Casadei
Space and time are key elements for many computer-based systems and often elevated to first-class abstractions. In tuple-based coordination, Linda primitives have been independently extended with space (with tuples and queries spanning spatial regions) or time information (mostly for tuple scoping). However, recent works in collective adaptive systems and aggregate computing show that space and time can naturally be considered as two intertwined facets of a common coordination abstraction for situated distributed systems. Accordingly, we introduce the Spatiotemporal Tuples model, a natural adaptation of Linda model for physically deployed large-scale networks. Unlike prior research, spatiotemporal properties – expressing where and when a tuple should range and has to be deposited/retrieved – naturally turn into specifications of collective adaptive processes, to be carried on in cooperation by the devices filling the computational environment, and sustaining tuple operations in a resilient way, possibly even in mobile and faulty environments. Additionally, the model promotes decentralised implementations where tuples actually reside where they are issued, which is good for supporting peer-to-peer and mobile ad-hoc networks as well as privacy. In this paper, we (i) present and formalise the Spatiotemporal Tuples model, based on the unifying notion of computational space-time structure, (ii) provide an implementation in the ScaFi aggregate computing framework, turning tuple operations into aggregate processes, and finally (iii) provide evaluation through simulation and a rescue case study.
A Programming Framework for Collective Adaptive EcosystemsRoberto Casadei
On the thrust of recent technological trends, we can
envision a future where dense ecosystems of digitally empowered devices
continuously adapt and operate in our environments to provide services
both to humans and other systems. To achieve that, we arguably need to
move beyond what an individual device can provide and rather focus on
what collectives of devices can offer as a system. Aggregate Computing
is a recent, promising framework generalising over spatial computing
approaches that supports the development of collective adaptive systems
by global specifications. It builds on the framework of the field
calculus to bridge the local and global perspectives, express
collective computations in a compositional way, and formally analyse
them to derive guarantees.
In this presentation, we describe the key concepts and results, take a
look at the practical support for Aggregate Computing on the JVM
provided by scafi, and consider the main research directions on the topic.
HDFS-HC: A Data Placement Module for Heterogeneous Hadoop ClustersXiao Qin
An increasing number of popular applications become data-intensive in nature. In the past decade, the World Wide Web has been adopted as an ideal platform for developing data-intensive applications, since the communication paradigm of the Web is sufficiently open and powerful. Data-intensive applications like data mining and web indexing need to access ever-expanding data sets ranging from a few gigabytes to several terabytes or even petabytes. Google leverages the MapReduce model to process approximately twenty petabytes of data per day in a parallel fashion. In this talk, we introduce the Google’s MapReduce framework for processing huge datasets on large clusters. We first outline the motivations of the MapReduce framework. Then, we describe the dataflow of MapReduce. Next, we show a couple of example applications of MapReduce. Finally, we present our research project on the Hadoop Distributed File System.
The current Hadoop implementation assumes that computing nodes in a cluster are homogeneous in nature. Data locality has not been taken into
account for launching speculative map tasks, because it is
assumed that most maps are data-local. Unfortunately, both
the homogeneity and data locality assumptions are not satisfied
in virtualized data centers. We show that ignoring the datalocality issue in heterogeneous environments can noticeably
reduce the MapReduce performance. In this paper, we address
the problem of how to place data across nodes in a way that
each node has a balanced data processing load. Given a dataintensive application running on a Hadoop MapReduce cluster,
our data placement scheme adaptively balances the amount of
data stored in each node to achieve improved data-processing
performance. Experimental results on two real data-intensive
applications show that our data placement strategy can always
improve the MapReduce performance by rebalancing data
across nodes before performing a data-intensive application
in a heterogeneous Hadoop cluster.
Collective Abstractions and Platforms for Large-Scale Self-Adaptive IoTRoberto Casadei
On the way to the materialisation of the pervasive computing vision, the technological progress swelling from mobile computing and the Internet of Things (IoT) domain is already rich of missed opportunities. Firstly, coordinating large numbers of heterogeneous situated entities to achieve system-level goals in a resilient and self-adaptive way is complex and requires novel approaches to be seamlessly injected into mainstream distributed computing models. Secondly, achieving effective exploitation of computer resources is difficult, due to operational constraints resulting from current paradigms and uncomprehensive software infrastructures which hinder flexibility, adaptation, and smooth coordination of computational tasks execution. Indeed, building dynamic, context-oriented applications in small- or large-scale IoT with traditional abstractions is hard: even harder is to achieve opportunistic, QoS- and QoE-driven application task management across available hardware and networking infras- tructure. In this insight paper, we analyse by the collective adap- tation perspective the key directions of the impelling paradigm shift urged by forthcoming large-scale IoT scenarios. Specifically, we consider how collective abstractions and platforms can syner- gistically assist in such a transformation, by better capturing and enacting a notion of “collective service” as well as the dynamic, opportunistic, and context-driven traits of space-time-situated computations.
Programming (and Learning) Self-Adaptive & Self-Organising Behaviour with Sca...Roberto Casadei
Large-scale and fully distributed cyber-physical sys-
tems (CPS), such as swarm robotics or IoT systems, pose
significant challenges for programming and design. These chal-
lenges include promoting the desired (emergent) collective and
self-organising behaviour, dealing with failures, enacting decen-
tralised coordination, and deploying efficient executions. Aggre-
gate computing is a promising approach that aims to simplify
the design of such systems by providing a high-level abstraction
for describing collective and self-organising behaviours. In this
tutorial, we introduce a toolchain that supports the development
of aggregate computing applications, based on ScaFi (a Scala-
based language and toolkit for aggregate computing) and Al-
chemist (a simulator for CPS scenarios). We will showcase the
toolchain by means of a series of examples, ranging from simple
collective behaviours to more complex self-adaptive and self-
organising ones. Finally, we provide several pointers to research
opportunities (e.g., related to learning collective behaviours
and adaptive large-scale deployments) and applications (e.g., in
swarm robotics, edge-cloud ecosystems, and more).
Engineering distributed applications and services in emerg-
ing and open computing scenarios like the Internet of Things, cyber-physical systems and pervasive computing, calls for identifying proper abstractions to smoothly capture collective behaviour, adaptivity, and dynamic injection and execution of concurrent distributed activities. Accordingly, we introduce a notion of “aggregate process” as a concurrent
field computation whose execution and interactions are sustained by a dynamic team of devices, and whose spatial region can opportunistically vary over time. We formalise this notion by extending the Field Calculus with a new primitive construct, spawn, used to instantiate a set of field
computations and regulate key aspects of their life-cycle. By virtue of an open-source implementation in the ScaFi framework, we show basic programming examples and benefits via two case studies of mobile ad-hoc networks and drone swarm scenarios, evaluated by simulation.
Presentation from Angular Sofia Meetup event focuses on integration between state-of-the-art Angular, component libraries and supporting technologies, necessary to build a scalable and performant single-page apps. Topics include:
- Composing NGRX Reducers, Selectors and Middleware;
- Computing derived data using Reselect-style memoization with RxJS;
- NGRX Router integration;
- Normalization/denormalization and keeping data locally in IndexedDB;
- Processing Observable (hot) streams of async actions, and isolating the side effects using @Effect decorator with NGRX/RxJS reactive transforms;
- Integration of Material Design with third party component libraries like PrimeNG;
- more: lazy loading, AOT...
This contains the agenda of the Spark Meetup I organised in Bangalore on Friday, the 23rd of Jan 2014. It carries the slides for the talk I gave on distributed deep learning over Spark
Conducting Experiments on the Software Architecture of Robotic Systems (QRARS...Ivano Malavolta
Slides of my invited talk at the 2nd workshop on Quality and Reliability Assessment of Robotic Software Architectures and Components (QRARSAC), co-located with the International Conference on Robotics and Automation (ICRA 2023).
Abstract of the talk. Today robotic systems are central to many industrial sectors, such as logistics, autonomous warehousing, and healthcare. If on one side ROS is helping roboticists by providing a standardized communication platform for robotic systems, on the other side ROSsystems are getting more and more large and complex, thus making it extremely difficult to ensure their level of quality, e.g., in terms of performance, security, energy efficiency, testability, maintainability. Improving the quality of robotic systems is not a new activity, but in this talk, we tackle it from a different perspective: we look at them from a software architecture perspective. In this talk, I will walk you through a series of experiments we conducted at the Vrije Universiteit Amsterdam targeting the architecture of ROS systems, we will discuss some architectural tactics for ROS systems, and will close with an overview of our open-source tool for automatically executing experiments on robotics software.
Concurrent execution of tasks can significantly improve its performance and efficiency. However, identifying which tasks can be executed concurrently and which tasks need to be executed sequentially can be a challenging task. In this talk, I propose using Inductive Logic Programming (ILP) to create a dynamic dependency graph for a given program. The graph can be used to identify which tasks can be executed concurrently and which tasks need to be executed sequentially. I demonstrate the effectiveness of this approach by applying it to a sample program and comparing its performance with a version that does not utilize concurrent execution. This talk presents a novel approach to creating a dynamic dependency graph for programs and highlights the potential benefits of using ILP for optimizing the performance of complex software systems.
Introduction to the 1st DISCOLI workshop on distributed collective intelligenceRoberto Casadei
The 1st DISCOLI workshop on DIStributed COLlective Intelligence is co-located with the 42nd IEEE International Conference on Distributed Computing Systems (ICDCS 2022) that will take place in Bologna, Italy, 10-13 July 2022.
Recent technological and scientific trends are promoting a vision where intelligence is more and more distributed and collective. Indeed, as computing and communication technologies are becoming increasingly pervasive, and complexity of systems is growing in terms of scale, heterogeneity, and interaction, hence the focus tends to shift from the intelligence of individual devices or agents to the collective intelligence (CI) emerging from a dynamic collection of diverse devices. Such intelligence would allow systems to address complex problems through proper coordination (e.g., cooperation or competition), to self-organise to promote functionality under changing environments, and to improve decision-making capabilities.
The workshop aims to provide a forum where researchers and practitioners can share and discuss fundamental concepts, models, and techniques for studying and implementing collectively intelligent distributed systems. Accordingly, it welcomes original research work providing ideas and technical contributions for promoting scientific discussion and practical adoption of CI mechanisms in engineered systems. As such, the workshop also welcomes cross-disciplinary contributions (e.g., extracting computational mechanisms from natural systems exhibiting forms of CI) and contributions from related research areas like coordination (the study of interaction), multi-agent systems (MAS), socio-technical systems, organisational paradigms, Wireless Sensor and Actuator Networks (WSANs), the Internet of Things (IoT), crowd computing, and swarm robotics.
The topics of interest include (but are not limited to) the following:
Algorithms for self-adaptive/self-organizing system behaviour
Algorithms of artificial collective intelligence (e.g., multi-agent reinforcement learning)
Techniques for task-specific collective intelligence
Extraction of collective knowledge in Internet of Things systems
Collaborations of humans and artificial agents in socio-technical systems
Formal models for computational collective intelligence
Design and verification of emergent properties in distributed systems
Coordination models and languages
Programming languages for distributed CI systems
Languages for multi-tier programming or macro-programming
CI for distributed wearable computing systems
Techniques for crowd computing systems and applications
Applications of distributed CI for smart environments (e.g., smart cities, smart buildings)
Tools for programming and simulation of multi-agent systems
6th eCAS workshop on Engineering Collective Adaptive SystemsRoberto Casadei
This is the presentation introducing the 6th eCAS workshop on Engineering Collective Adaptive Systems. It recaps its scope, provides data regarding this edition, provides an overview of the program and related initiatives.
More Related Content
Similar to Self-Organisation Programming: a Functional Reactive Macro Approach (FRASP) [Presentation at ACSOS'23]
Aggregate programming is a novel paradigm that addresses, at the core, many issues commonly found in the development of large-scale, situated, self-adaptive systems. It is a particular macro-programming approach where a developer expresses the behaviour of the system at the aggregate-level, by targeting the distributed computational machine which is given by the entire set of (possibly mobile and heterogeneous) networked devices pervading the environment. It is the model that takes care of turning a system-level behaviour specification into the concrete, device-centric programs executed locally by each component.
Aggregate computing is formally grounded in the field calculus, a minimal functional language that works with computational fields, i.e., distributed data structures mapping devices (digital representatives of space-time portions) to computational objects. Fields are a useful unifying abstraction for drawing a connection between the physical and the computational world, and between the local and global programming viewpoints. This approach is compositional, allowing to define layers of building blocks of increasing abstraction, and is also amenable to formal analyses.
In this talk, I will present scafi (SCAla with computational FIels), an aggregate computing framework for the Scala programming language which provides (i) an internal DSL for expressing aggregate computations as well as (ii) a library support for the configuration and execution of aggregate systems. There is no need to learn ad-hoc external DSLs anymore: with scafi, Scala programmers can instantaneously start playing with this new, intriguing development approach!
Augmented Collective Digital Twins for Self-Organising Cyber-Physical SystemsRoberto Casadei
Context. Self-organising and collective computing
approaches are increasingly applied to large-scale cyber-physical
systems (CPS), enabling them to adapt and cooperate in dynamic
environments. Also, in CPS engineering, digital twins are often
leveraged to provide synchronised logical counterparts of physical
entities, whereas in sensor networks the different-but-related
concept of virtual device is used e.g. to abstract groups of sensors.
Vision. We envision the design concept of “augmented collective
digital twin” that captures digital twins at a collective level
extended with purely virtual devices. We argue that this concept
can foster the engineering of self-organising CPS by providing a
holistic, declarative, and integrated system view.
Method. From a review and proposed taxonomy of logical
devices comprehending both digital twins and virtual devices,
we reinterpret a meta-model for self-organising CPSs and discuss
how it can support augmented collective digital twins. We illus-
trate the approach in a crowd-aware navigation scenario, where
virtual devices are opportunistically integrated into the system
to enhance spatial coverage, improving navigation capabilities.
Conclusion. By integrating physical and virtual devices, the
novel notion of augmented collective digital twin paves the way
to self-improving system functionality and intelligent use of
resources in self-organising CPSs.
On Execution Platforms for Large-Scale Aggregate ComputingRoberto Casadei
Aggregate computing is proposed as a computational model and associated toolchain to engineer adaptive large-scale situated systems, including IoT and wearable computing systems. Though originated in the context of WSN-like (peer-to-peer and fully distributed) systems, we argue it is a model that can transparently fit a variety of execution platforms (decentralised, server-mediated, cloud/fog-oriented), due to its ability of declaratively designing systems by global-level abstractions: it opens the possibility of intrinsically supporting forms of load balancing, elasticity and toleration of medium- and long-term changes of computational infrastructures. To ground the discussion, we present ongoing work in the context of scafi, a language and platform support for computational fields based on the Scala programming language and Akka actor framework.
Coordinating Computation at the Edge: a Decentralized, Self-organizing, Spati...Roberto Casadei
Presentation of a paper accepted at the 4th Internetional Conference on Fog and Mobile Edge Computing (FMEC).
It discusses a decentralised, self-organising, spatial, collective approach to the development of edge-clouds/edge computing ecosystems.
Tuple-Based Coordination in Large-Scale Situated SystemsRoberto Casadei
Space and time are key elements for many computer-based systems and often elevated to first-class abstractions. In tuple-based coordination, Linda primitives have been independently extended with space (with tuples and queries spanning spatial regions) or time information (mostly for tuple scoping). However, recent works in collective adaptive systems and aggregate computing show that space and time can naturally be considered as two intertwined facets of a common coordination abstraction for situated distributed systems. Accordingly, we introduce the Spatiotemporal Tuples model, a natural adaptation of Linda model for physically deployed large-scale networks. Unlike prior research, spatiotemporal properties – expressing where and when a tuple should range and has to be deposited/retrieved – naturally turn into specifications of collective adaptive processes, to be carried on in cooperation by the devices filling the computational environment, and sustaining tuple operations in a resilient way, possibly even in mobile and faulty environments. Additionally, the model promotes decentralised implementations where tuples actually reside where they are issued, which is good for supporting peer-to-peer and mobile ad-hoc networks as well as privacy. In this paper, we (i) present and formalise the Spatiotemporal Tuples model, based on the unifying notion of computational space-time structure, (ii) provide an implementation in the ScaFi aggregate computing framework, turning tuple operations into aggregate processes, and finally (iii) provide evaluation through simulation and a rescue case study.
A Programming Framework for Collective Adaptive EcosystemsRoberto Casadei
On the thrust of recent technological trends, we can
envision a future where dense ecosystems of digitally empowered devices
continuously adapt and operate in our environments to provide services
both to humans and other systems. To achieve that, we arguably need to
move beyond what an individual device can provide and rather focus on
what collectives of devices can offer as a system. Aggregate Computing
is a recent, promising framework generalising over spatial computing
approaches that supports the development of collective adaptive systems
by global specifications. It builds on the framework of the field
calculus to bridge the local and global perspectives, express
collective computations in a compositional way, and formally analyse
them to derive guarantees.
In this presentation, we describe the key concepts and results, take a
look at the practical support for Aggregate Computing on the JVM
provided by scafi, and consider the main research directions on the topic.
HDFS-HC: A Data Placement Module for Heterogeneous Hadoop ClustersXiao Qin
An increasing number of popular applications become data-intensive in nature. In the past decade, the World Wide Web has been adopted as an ideal platform for developing data-intensive applications, since the communication paradigm of the Web is sufficiently open and powerful. Data-intensive applications like data mining and web indexing need to access ever-expanding data sets ranging from a few gigabytes to several terabytes or even petabytes. Google leverages the MapReduce model to process approximately twenty petabytes of data per day in a parallel fashion. In this talk, we introduce the Google’s MapReduce framework for processing huge datasets on large clusters. We first outline the motivations of the MapReduce framework. Then, we describe the dataflow of MapReduce. Next, we show a couple of example applications of MapReduce. Finally, we present our research project on the Hadoop Distributed File System.
The current Hadoop implementation assumes that computing nodes in a cluster are homogeneous in nature. Data locality has not been taken into
account for launching speculative map tasks, because it is
assumed that most maps are data-local. Unfortunately, both
the homogeneity and data locality assumptions are not satisfied
in virtualized data centers. We show that ignoring the datalocality issue in heterogeneous environments can noticeably
reduce the MapReduce performance. In this paper, we address
the problem of how to place data across nodes in a way that
each node has a balanced data processing load. Given a dataintensive application running on a Hadoop MapReduce cluster,
our data placement scheme adaptively balances the amount of
data stored in each node to achieve improved data-processing
performance. Experimental results on two real data-intensive
applications show that our data placement strategy can always
improve the MapReduce performance by rebalancing data
across nodes before performing a data-intensive application
in a heterogeneous Hadoop cluster.
Collective Abstractions and Platforms for Large-Scale Self-Adaptive IoTRoberto Casadei
On the way to the materialisation of the pervasive computing vision, the technological progress swelling from mobile computing and the Internet of Things (IoT) domain is already rich of missed opportunities. Firstly, coordinating large numbers of heterogeneous situated entities to achieve system-level goals in a resilient and self-adaptive way is complex and requires novel approaches to be seamlessly injected into mainstream distributed computing models. Secondly, achieving effective exploitation of computer resources is difficult, due to operational constraints resulting from current paradigms and uncomprehensive software infrastructures which hinder flexibility, adaptation, and smooth coordination of computational tasks execution. Indeed, building dynamic, context-oriented applications in small- or large-scale IoT with traditional abstractions is hard: even harder is to achieve opportunistic, QoS- and QoE-driven application task management across available hardware and networking infras- tructure. In this insight paper, we analyse by the collective adap- tation perspective the key directions of the impelling paradigm shift urged by forthcoming large-scale IoT scenarios. Specifically, we consider how collective abstractions and platforms can syner- gistically assist in such a transformation, by better capturing and enacting a notion of “collective service” as well as the dynamic, opportunistic, and context-driven traits of space-time-situated computations.
Programming (and Learning) Self-Adaptive & Self-Organising Behaviour with Sca...Roberto Casadei
Large-scale and fully distributed cyber-physical sys-
tems (CPS), such as swarm robotics or IoT systems, pose
significant challenges for programming and design. These chal-
lenges include promoting the desired (emergent) collective and
self-organising behaviour, dealing with failures, enacting decen-
tralised coordination, and deploying efficient executions. Aggre-
gate computing is a promising approach that aims to simplify
the design of such systems by providing a high-level abstraction
for describing collective and self-organising behaviours. In this
tutorial, we introduce a toolchain that supports the development
of aggregate computing applications, based on ScaFi (a Scala-
based language and toolkit for aggregate computing) and Al-
chemist (a simulator for CPS scenarios). We will showcase the
toolchain by means of a series of examples, ranging from simple
collective behaviours to more complex self-adaptive and self-
organising ones. Finally, we provide several pointers to research
opportunities (e.g., related to learning collective behaviours
and adaptive large-scale deployments) and applications (e.g., in
swarm robotics, edge-cloud ecosystems, and more).
Engineering distributed applications and services in emerg-
ing and open computing scenarios like the Internet of Things, cyber-physical systems and pervasive computing, calls for identifying proper abstractions to smoothly capture collective behaviour, adaptivity, and dynamic injection and execution of concurrent distributed activities. Accordingly, we introduce a notion of “aggregate process” as a concurrent
field computation whose execution and interactions are sustained by a dynamic team of devices, and whose spatial region can opportunistically vary over time. We formalise this notion by extending the Field Calculus with a new primitive construct, spawn, used to instantiate a set of field
computations and regulate key aspects of their life-cycle. By virtue of an open-source implementation in the ScaFi framework, we show basic programming examples and benefits via two case studies of mobile ad-hoc networks and drone swarm scenarios, evaluated by simulation.
Presentation from Angular Sofia Meetup event focuses on integration between state-of-the-art Angular, component libraries and supporting technologies, necessary to build a scalable and performant single-page apps. Topics include:
- Composing NGRX Reducers, Selectors and Middleware;
- Computing derived data using Reselect-style memoization with RxJS;
- NGRX Router integration;
- Normalization/denormalization and keeping data locally in IndexedDB;
- Processing Observable (hot) streams of async actions, and isolating the side effects using @Effect decorator with NGRX/RxJS reactive transforms;
- Integration of Material Design with third party component libraries like PrimeNG;
- more: lazy loading, AOT...
This contains the agenda of the Spark Meetup I organised in Bangalore on Friday, the 23rd of Jan 2014. It carries the slides for the talk I gave on distributed deep learning over Spark
Conducting Experiments on the Software Architecture of Robotic Systems (QRARS...Ivano Malavolta
Slides of my invited talk at the 2nd workshop on Quality and Reliability Assessment of Robotic Software Architectures and Components (QRARSAC), co-located with the International Conference on Robotics and Automation (ICRA 2023).
Abstract of the talk. Today robotic systems are central to many industrial sectors, such as logistics, autonomous warehousing, and healthcare. If on one side ROS is helping roboticists by providing a standardized communication platform for robotic systems, on the other side ROSsystems are getting more and more large and complex, thus making it extremely difficult to ensure their level of quality, e.g., in terms of performance, security, energy efficiency, testability, maintainability. Improving the quality of robotic systems is not a new activity, but in this talk, we tackle it from a different perspective: we look at them from a software architecture perspective. In this talk, I will walk you through a series of experiments we conducted at the Vrije Universiteit Amsterdam targeting the architecture of ROS systems, we will discuss some architectural tactics for ROS systems, and will close with an overview of our open-source tool for automatically executing experiments on robotics software.
Concurrent execution of tasks can significantly improve its performance and efficiency. However, identifying which tasks can be executed concurrently and which tasks need to be executed sequentially can be a challenging task. In this talk, I propose using Inductive Logic Programming (ILP) to create a dynamic dependency graph for a given program. The graph can be used to identify which tasks can be executed concurrently and which tasks need to be executed sequentially. I demonstrate the effectiveness of this approach by applying it to a sample program and comparing its performance with a version that does not utilize concurrent execution. This talk presents a novel approach to creating a dynamic dependency graph for programs and highlights the potential benefits of using ILP for optimizing the performance of complex software systems.
Similar to Self-Organisation Programming: a Functional Reactive Macro Approach (FRASP) [Presentation at ACSOS'23] (20)
Introduction to the 1st DISCOLI workshop on distributed collective intelligenceRoberto Casadei
The 1st DISCOLI workshop on DIStributed COLlective Intelligence is co-located with the 42nd IEEE International Conference on Distributed Computing Systems (ICDCS 2022) that will take place in Bologna, Italy, 10-13 July 2022.
Recent technological and scientific trends are promoting a vision where intelligence is more and more distributed and collective. Indeed, as computing and communication technologies are becoming increasingly pervasive, and complexity of systems is growing in terms of scale, heterogeneity, and interaction, hence the focus tends to shift from the intelligence of individual devices or agents to the collective intelligence (CI) emerging from a dynamic collection of diverse devices. Such intelligence would allow systems to address complex problems through proper coordination (e.g., cooperation or competition), to self-organise to promote functionality under changing environments, and to improve decision-making capabilities.
The workshop aims to provide a forum where researchers and practitioners can share and discuss fundamental concepts, models, and techniques for studying and implementing collectively intelligent distributed systems. Accordingly, it welcomes original research work providing ideas and technical contributions for promoting scientific discussion and practical adoption of CI mechanisms in engineered systems. As such, the workshop also welcomes cross-disciplinary contributions (e.g., extracting computational mechanisms from natural systems exhibiting forms of CI) and contributions from related research areas like coordination (the study of interaction), multi-agent systems (MAS), socio-technical systems, organisational paradigms, Wireless Sensor and Actuator Networks (WSANs), the Internet of Things (IoT), crowd computing, and swarm robotics.
The topics of interest include (but are not limited to) the following:
Algorithms for self-adaptive/self-organizing system behaviour
Algorithms of artificial collective intelligence (e.g., multi-agent reinforcement learning)
Techniques for task-specific collective intelligence
Extraction of collective knowledge in Internet of Things systems
Collaborations of humans and artificial agents in socio-technical systems
Formal models for computational collective intelligence
Design and verification of emergent properties in distributed systems
Coordination models and languages
Programming languages for distributed CI systems
Languages for multi-tier programming or macro-programming
CI for distributed wearable computing systems
Techniques for crowd computing systems and applications
Applications of distributed CI for smart environments (e.g., smart cities, smart buildings)
Tools for programming and simulation of multi-agent systems
6th eCAS workshop on Engineering Collective Adaptive SystemsRoberto Casadei
This is the presentation introducing the 6th eCAS workshop on Engineering Collective Adaptive Systems. It recaps its scope, provides data regarding this edition, provides an overview of the program and related initiatives.
Testing: an Introduction and Panorama
- what testing is
- perspectives on testing
- xUnit, TDD, acceptance testing
- pointers to more stuff about testing
On Context-Orientation in Aggregate ProgrammingRoberto Casadei
Context-awareness plays a central role in self-
adaptive software. By a programming perspective, context is
often used implicitly, and context-aware code is fragmented
in the codebase. In Context-Oriented Programming, instead,
context is considered a first-class citizen and is explicitly used
to modularise context-sensitive functionality and behavioural
variability. In this paper, we reflect on the role of context in
collective adaptive systems, by a discussion from the special
perspective of a macro paradigm, Aggregate Programming,
which supports the specification of collective behaviour by a
global perspective through functional compositions of field com-
putations. In particular, we consider the abstractions exposed in
Context-Oriented and Aggregate Programming, suggest potential
synergies in both directions, and accordingly take the first steps
towards a combined design.
Novel scenarios like IoT and smart cities promote
a vision of computational ecosystems whereby heterogeneous
collectives of humans, devices and computing infrastructure
interact to provide various services. There, autonomous agents
with different capabilities are expected to cooperate towards
global goals in dependable ways. This is challenging, as deployments are within unknown, changing and loosely connected environments characterized by lack of centralized control, where
components may come and go, or disruption may be caused by
failures. Key issues include (i) how to leverage, functionally and
non-functionally, forms of opportunistic computing and locality
that often underlie IoT scenarios; (ii) how to design and operate
large-scale, resilient ecosystems through suitable assumptions,
decentralized control, and adaptive mechanisms; and (iii) how
to capture and enact “global” behaviors and properties, when
the system consists of heterogeneous, autonomous entities. In
this paper, we propose a model for resilient, collaborative edge-
enabled IoT that leverages spatial locality, opportunistic agents,
and coordinator nodes at the edge. The engineering approach
is declarative and configurable, and works by dynamically
dividing the environment into collaboration areas coordinated
by edge devices. We provide an implementation as a collective, self-organizing workflow based on Aggregate Computing,
provide evaluation by means of simulation, and finally discuss
properties and general applicability of the approach.
Brief overview of the Rust system programming language. Provides a concise introduction of its basic features, with an emphasis on its memory safety features (ownership, moves, borrowing) and programming style with generic functions, structures, and traits.
Richard's entangled aventures in wonderlandRichard Gill
Since the loophole-free Bell experiments of 2020 and the Nobel prizes in physics of 2022, critics of Bell's work have retreated to the fortress of super-determinism. Now, super-determinism is a derogatory word - it just means "determinism". Palmer, Hance and Hossenfelder argue that quantum mechanics and determinism are not incompatible, using a sophisticated mathematical construction based on a subtle thinning of allowed states and measurements in quantum mechanics, such that what is left appears to make Bell's argument fail, without altering the empirical predictions of quantum mechanics. I think however that it is a smoke screen, and the slogan "lost in math" comes to my mind. I will discuss some other recent disproofs of Bell's theorem using the language of causality based on causal graphs. Causal thinking is also central to law and justice. I will mention surprising connections to my work on serial killer nurse cases, in particular the Dutch case of Lucia de Berk and the current UK case of Lucy Letby.
Multi-source connectivity as the driver of solar wind variability in the heli...Sérgio Sacani
The ambient solar wind that flls the heliosphere originates from multiple
sources in the solar corona and is highly structured. It is often described
as high-speed, relatively homogeneous, plasma streams from coronal
holes and slow-speed, highly variable, streams whose source regions are
under debate. A key goal of ESA/NASA’s Solar Orbiter mission is to identify
solar wind sources and understand what drives the complexity seen in the
heliosphere. By combining magnetic feld modelling and spectroscopic
techniques with high-resolution observations and measurements, we show
that the solar wind variability detected in situ by Solar Orbiter in March
2022 is driven by spatio-temporal changes in the magnetic connectivity to
multiple sources in the solar atmosphere. The magnetic feld footpoints
connected to the spacecraft moved from the boundaries of a coronal hole
to one active region (12961) and then across to another region (12957). This
is refected in the in situ measurements, which show the transition from fast
to highly Alfvénic then to slow solar wind that is disrupted by the arrival of
a coronal mass ejection. Our results describe solar wind variability at 0.5 au
but are applicable to near-Earth observatories.
THE IMPORTANCE OF MARTIAN ATMOSPHERE SAMPLE RETURN.Sérgio Sacani
The return of a sample of near-surface atmosphere from Mars would facilitate answers to several first-order science questions surrounding the formation and evolution of the planet. One of the important aspects of terrestrial planet formation in general is the role that primary atmospheres played in influencing the chemistry and structure of the planets and their antecedents. Studies of the martian atmosphere can be used to investigate the role of a primary atmosphere in its history. Atmosphere samples would also inform our understanding of the near-surface chemistry of the planet, and ultimately the prospects for life. High-precision isotopic analyses of constituent gases are needed to address these questions, requiring that the analyses are made on returned samples rather than in situ.
This pdf is about the Schizophrenia.
For more details visit on YouTube; @SELF-EXPLANATORY;
https://www.youtube.com/channel/UCAiarMZDNhe1A3Rnpr_WkzA/videos
Thanks...!
Nutraceutical market, scope and growth: Herbal drug technologyLokesh Patil
As consumer awareness of health and wellness rises, the nutraceutical market—which includes goods like functional meals, drinks, and dietary supplements that provide health advantages beyond basic nutrition—is growing significantly. As healthcare expenses rise, the population ages, and people want natural and preventative health solutions more and more, this industry is increasing quickly. Further driving market expansion are product formulation innovations and the use of cutting-edge technology for customized nutrition. With its worldwide reach, the nutraceutical industry is expected to keep growing and provide significant chances for research and investment in a number of categories, including vitamins, minerals, probiotics, and herbal supplements.
Nutraceutical market, scope and growth: Herbal drug technology
Self-Organisation Programming: a Functional Reactive Macro Approach (FRASP) [Presentation at ACSOS'23]
1. Self-Organisation Programming:
a Functional Reactive Macro Approach
Roberto Casadei, Francesco Dente,
Gianluca Aguzzi, Danilo Pianini, Mirko Viroli
Department of Computer Science and Engineering
ALMA MATER STUDIORUM – Università of Bologna
June 21st, 2023
ACSOS’23, Toronto, Canada
https://www.slideshare.net/RobertoCasadei
R. Casadei Motivation Contribution Wrap-up References 1/16
3. Context and Goals
building collective intelligence [1] in large-scale artificial systems
e.g.: swarms, edge-cloud infrastructures, crowds of wearable-augmented people
[1] R. Casadei, “Artificial Collective Intelligence Engineering: A Survey of Concepts and Perspectives,” Artificial Life,
Jul. 2023
R. Casadei Motivation Contribution Wrap-up References 2/16
4. A key problem: self-organisation engineering
how to drive the (emergence of the) self-organisation in a
collection of agents or devices?
[2] G. Aguzzi, R. Casadei, and M. Viroli, “Towards reinforcement learning-based aggregate computing,” in
COORDINATION, ser. LNCS, Springer, 2022
[3] R. Casadei, “Macroprogramming: Concepts, state of the art, and opportunities of macroscopic behaviour
modelling,” ACM Comput. Surv., no. 13s, 2023
[4] J. Beal, D. Pianini, and M. Viroli, “Aggregate programming for the internet of things,” IEEE Computer, no. 9, 2015
R. Casadei Motivation Contribution Wrap-up References 3/16
5. A key problem: self-organisation engineering
how to drive the (emergence of the) self-organisation in a
collection of agents or devices?
self-organisation engineering
(semi-)automatic approaches
MARL Program Synthesis [2] ...
“manual” approaches
node-centric
TOTA (reactive tuples)
...
macro-programming [3]
aggregate computing [4]
[2] G. Aguzzi, R. Casadei, and M. Viroli, “Towards reinforcement learning-based aggregate computing,” in
COORDINATION, ser. LNCS, Springer, 2022
[3] R. Casadei, “Macroprogramming: Concepts, state of the art, and opportunities of macroscopic behaviour
modelling,” ACM Comput. Surv., no. 13s, 2023
[4] J. Beal, D. Pianini, and M. Viroli, “Aggregate programming for the internet of things,” IEEE Computer, no. 9, 2015
R. Casadei Motivation Contribution Wrap-up References 3/16
6. SotA: Aggregate Computing (AC) (in 1 Slide)
Self-org-like computational model
structure: graph w/ local neighbourhoods
interaction: repeated msg exchange with neighbours
behaviour: repeated execution of async rounds of sense
– compute – (inter)act (program maps context to act)
R. Casadei Motivation Contribution Wrap-up References 4/16
7. SotA: Aggregate Computing (AC) (in 1 Slide)
Self-org-like computational model
structure: graph w/ local neighbourhoods
interaction: repeated msg exchange with neighbours
behaviour: repeated execution of async rounds of sense
– compute – (inter)act (program maps context to act)
formal model of executions: 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
R. Casadei Motivation Contribution Wrap-up References 4/16
8. SotA: Aggregate Computing (AC) (in 1 Slide)
Self-org-like computational model
structure: graph w/ local neighbourhoods
interaction: repeated msg exchange with neighbours
behaviour: repeated execution of async rounds of sense
– compute – (inter)act (program maps context to act)
abstraction: computational fields (dev/evt 7→ V)
formal core language: field calculus [5]
paradigm: functional, macro-programming
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)
M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini, “From dis-
tributed coordination to field calculus and aggregate computing,” J. Log. Algebraic
Methods Program., 2019
formal model of executions: 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
R. Casadei Motivation Contribution Wrap-up References 4/16
9. SotA: Aggregate Computing (AC) (in 1 Slide)
Self-org-like computational model
structure: graph w/ local neighbourhoods
interaction: repeated msg exchange with neighbours
behaviour: repeated execution of async rounds of sense
– compute – (inter)act (program maps context to act)
abstraction: computational fields (dev/evt 7→ V)
formal core language: field calculus [5]
paradigm: functional, macro-programming
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)
M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini, “From dis-
tributed coordination to field calculus and aggregate computing,” J. Log. Algebraic
Methods Program., 2019
formal model of executions: 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
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
J. Beal, D. Pianini, and M. Viroli, “Aggregate programming for the internet of
things,” IEEE Computer, no. 9, 2015
R. Casadei Motivation Contribution Wrap-up References 4/16
10. Motivation: combining strengths from SotA approaches
Feature TOTA aggregate computing
programming
approach , local-to-global - global-to-local
complexity
management “ modularity - compositionality
declarativeness
- high - high
scheduling ap-
proach - reactive , periodic (round-based)
scheduling
granularity - fine-grained , coarse-grained
R. Casadei Motivation Contribution Wrap-up References 5/16
11. Motivation: combining strengths from SotA approaches
Feature TOTA aggregate com-
puting
FRASP
programming
approach , local-to-global - global-to-local - global-to-local
complexity
management “ modularity - compositionality - compositionality
declarativeness
- high - high - high
scheduling ap-
proach - reactive , periodic (round-
based)
- reactive
scheduling
granularity - fine-grained , coarse-grained - fine-grained
R. Casadei Motivation Contribution Wrap-up References 5/16
14. FRASP
FRASP
is a
Functional Reactive Approach
to
Self-organisation Programming
designed by interpreting the aggregate programming model by a (distributed) functional
reactive programming (FRP) perspective [6]
impl as a Scala DSL using Sodium FRP library
R. Casadei Motivation Contribution Wrap-up References 6/16
15. FRASP
FRASP
is a
Functional Reactive Approach
to
Self-organisation Programming
designed by interpreting the aggregate programming model by a (distributed) functional
reactive programming (FRP) perspective [6]
impl as a Scala DSL using Sodium FRP library
FRP in a nutshell
FRP provides abstractions to express and combine time-varying values into a
dependency graph
1 val v1 = /* ... */ ;
2 val v2 = /* ... */ ;
3 val v3 = v1 + v2 ; // v3 gets updated upon change of v1 or v2
R. Casadei Motivation Contribution Wrap-up References 6/16
16. FRASP
FRASP
is a
Functional Reactive Approach
to
Self-organisation Programming
designed by interpreting the aggregate programming model by a (distributed) functional
reactive programming (FRP) perspective [6]
impl as a Scala DSL using Sodium FRP library
FRP in a nutshell
FRP provides abstractions to express and combine time-varying values into a
dependency graph
1 val v1 = /* ... */ ;
2 val v2 = /* ... */ ;
3 val v3 = v1 + v2 ; // v3 gets updated upon change of v1 or v2
AC + FRP: intuition
1 val selforgSubRes1 = f(/* ... */);
2 val selforgSubRes2 = g(/* ... */);
3 val selforgOutput = h(selforgSubRes1, selforgSubRes2); // h re-eval'ed iff inputs change
R. Casadei Motivation Contribution Wrap-up References 6/16
17. FRASP in a nutshell
Data types
Flow[T]: a reactive collective
sub-computation representing a
time-varying signal of Ts
distributed! each device get its own
“flow” for a single task; the system
behaviour/result for the task is given by
all these flows
NbrField[T]: a collection of data from
neighbours
Neighbouring sensors
1 def nbrRange(): Flow[NbrField[Double]] =
2 nbrSensor(nbrRange)
Stateful flow evolution
1 loop(0)(v = v + 1) // implicitly
throttling
mux: strict choice
1 mux(sensor(temperature) THRESHOLD) {
2 constant(hot)
3 } {
4 constant(normal)
5 }
branch: non-strict choice
1 branch(sensor(color) == red){
2 nbr(constant(1)).sum // run by reds
3 } {
4 nbr(constant(1)).sum // run by blues
5 }
lift: combining flows
1 lift(nbr(mid(),nbrRange()){ (nId,nDst) =
2 s${nId} is at distance ${nDst}
3 }
R. Casadei Motivation Contribution Wrap-up References 7/16
18. Example: gradient
Code and graphical representation of execution https://youtu.be/3QIWfNq3yxU
1 def gradient(source: Flow[Boolean]): Flow[Double] =
2 loop(Double.PositiveInfinity) { g = {
3 mux(source) {
4 constant(0.0)
5 } {
6 lift(nbrRange(), nbr(g))(_ + _).withoutSelf.min
7 }
8 }
gradient: field of minimum distances from source
Notation
∠ blue shadow: source
∠ gray: obstacle (no gradient computation)
∠ hotter colours → lower distance to source
R. Casadei Motivation Contribution Wrap-up References 8/16
21. Example: self-healing channel
Graphical representation of dependencies among reactive self-organising computations
source destination
gradient distance
gradient
=
+
dilate
width
37
10
Channel
gradient
(source)
gradient
(destination)
distanceBetween
source destination
Sub-
computations
Computation
Sensors
nbrRange
Input
Width
Platform
Local sensors
Neighbour data
R. Casadei Motivation Contribution Wrap-up References 11/16
22. Example: self-healing channel
Reactive Dynamics https://youtu.be/j_JX5wW03-w
stabilised channel (connects source to destination via a path of devices)
R. Casadei Motivation Contribution Wrap-up References 12/16
23. Example: self-healing channel
Reactive Dynamics https://youtu.be/j_JX5wW03-w
a new potential destination appears
R. Casadei Motivation Contribution Wrap-up References 12/16
24. Example: self-healing channel
Reactive Dynamics https://youtu.be/j_JX5wW03-w
the channel gets recomputed
R. Casadei Motivation Contribution Wrap-up References 12/16
25. Example: self-healing channel
Reactive Dynamics https://youtu.be/j_JX5wW03-w
the channel gets recomputed
R. Casadei Motivation Contribution Wrap-up References 12/16
26. Example: self-healing channel
Reactive Dynamics https://youtu.be/j_JX5wW03-w
the channel gets recomputed
R. Casadei Motivation Contribution Wrap-up References 12/16
27. Example: self-healing channel
Reactive Dynamics https://youtu.be/j_JX5wW03-w
the channel re-stabilises
R. Casadei Motivation Contribution Wrap-up References 12/16
30. Conclusion
FRASP (Functional Reactive Approach to Self-Org Programming) re-interprets the
aggregate programming model by a functional reactive programming (FRP) perspective
R. Casadei Motivation Contribution Wrap-up References 14/16
31. Conclusion
FRASP (Functional Reactive Approach to Self-Org Programming) re-interprets the
aggregate programming model by a functional reactive programming (FRP) perspective
∠ and also provides an original flavour of distributed FRP
R. Casadei Motivation Contribution Wrap-up References 14/16
32. Conclusion
FRASP (Functional Reactive Approach to Self-Org Programming) re-interprets the
aggregate programming model by a functional reactive programming (FRP) perspective
∠ and also provides an original flavour of distributed FRP
Combines the benefits of existing approaches (cf. AC and TOTA)
∠ expressiveness and compositionality
∠ reactive execution (configurable)
∠ fine-grained reactive execution (not only the whole programs but parts of it)
R. Casadei Motivation Contribution Wrap-up References 14/16
33. Conclusion
FRASP (Functional Reactive Approach to Self-Org Programming) re-interprets the
aggregate programming model by a functional reactive programming (FRP) perspective
∠ and also provides an original flavour of distributed FRP
Combines the benefits of existing approaches (cf. AC and TOTA)
∠ expressiveness and compositionality
∠ reactive execution (configurable)
∠ fine-grained reactive execution (not only the whole programs but parts of it)
Future work
∠ libraries of reactive self-org blocks
∠ implementation of advanced self-org constructs like aggregate processes
R. Casadei Motivation Contribution Wrap-up References 14/16
35. References (1/1)
[1] R. Casadei, “Artificial Collective Intelligence Engineering: A Survey of Concepts and Perspectives,”
Artificial Life, pp. 1–35, Jul. 2023, ISSN: 1064-5462. DOI: 10.1162/artl_a_00408.
[2] G. Aguzzi, R. Casadei, and M. Viroli, “Towards reinforcement learning-based aggregate computing,”
in COORDINATION, ser. LNCS, vol. 13271, Springer, 2022, pp. 72–91. DOI:
10.1007/978-3-031-08143-9_5.
[3] R. Casadei, “Macroprogramming: Concepts, state of the art, and opportunities of macroscopic
behaviour modelling,” ACM Comput. Surv., vol. 55, no. 13s, 2023, ISSN: 0360-0300. DOI:
10.1145/3579353.
[4] J. Beal, D. Pianini, and M. Viroli, “Aggregate programming for the internet of things,” IEEE Computer,
vol. 48, no. 9, pp. 22–30, 2015. DOI: 10.1109/MC.2015.261.
[5] M. Viroli, J. Beal, F. Damiani, G. Audrito, R. Casadei, and D. Pianini, “From distributed coordination to
field calculus and aggregate computing,” J. Log. Algebraic Methods Program., vol. 109, 2019. DOI:
10.1016/j.jlamp.2019.100486.
[6] E. Bainomugisha, A. L. Carreton, T. V. Cutsem, S. Mostinckx, and W. D. Meuter, “A survey on reactive
programming,” ACM Comput. Surv., vol. 45, no. 4, 52:1–52:34, 2013. DOI:
10.1145/2501654.2501666.
R. Casadei Motivation Contribution Wrap-up References 16/16