has a macro-level denotational semantics
to the local operational semantics <cit.>,
using computational fields (global data structures) as bridging abstraction.

§.§.§  abstractions

Finally, we can observe that a number of abstractions
or features
recur in  approaches. These include:

* first-class groups—the ability to directly express and manipulate groups of individuals (cf. group handles in EcoCast, swarms in Buzz or PaROS);

* group lifecycle management—the ability to evolve groups dynamically (cf. dynamic binding in Warble);

* group addressing—the ability to address a group, e.g., in terms of the individuals found in a certain spatial region
or that share certain capabilities (cf. Regiment, SpatialViews, STOP/Chronus);

* distributed state—the ability to address the state of a group of stateful entities (cf. fields in aggregate programming, state rewriting in Comingle);

* group inspection—the ability to inspect or iterate over the individuals of a group (cf. node iteration in Kairos, resources in PyoT);

* group goal decomposition—the ability to consider a global goal
and ways to split it across multiple individuals (cf. task partitioning in PaROS, spatial decomposition in Karma);

* group communication—the ability to get data from or push data to a group (cf. report/tell/collective actions in makeSense,
or neighbourhood-based communication in COSMOS, and aggregate programming);

* information flow patterns—the ability to specify
how information should flow independently
of structure or concrete communication mechanisms
(cf. ATaG);

* group-level actions—the ability to express what a group should do (cf. functions in aggregate programming, activity nodes in DDFlow).

Sometimes, some of these aspects are abstracted away
and implemented at the middleware layer:
for instance,
approaches that consider a WSN “like a database”
let the programmer express a query (global goal)
then handle its partitioning into micro-actions through underlying mechanisms and execution protocols.

§.§.§ On implementation and abstracted concerns

A major goal of
is abstracting from
a series of low-level concerns.
This is also strikingly evident
from the quotes reported in <Ref>,
which suggest that the programmer
can be relieved from
“explicitly managing control, coordination, and state maintenance at the individual node level” <cit.>
in order to retrieve “simplicity and productivity” <cit.>
through “focus on application specification rather
than low-level details or inter-node messaging” <cit.>.
Besides productivity,
there is also the idea that
low-level details
can be addressed efficiently or opportunistically
at the middleware level—see <Ref> for further considerations on this point.

The concerns that are abstracted may be classified
according to the fundamental dimensions of
structure, behaviour, and interaction.
Structural concerns
include connections between components
and membership relationships.
As these elements tend to change dynamically,
expressing them in a declarative fashion
enables the underlying platform
to adopt flexible strategies for their reification.
For instance, in Buzz <cit.>,
each robot follows a protocol
to keep track of its membership in swarms,
which further affects the set of its neighbours.
In ScaFi <cit.>,
groups self-organise
by playing the logic expressed by the macroprogram
in repeated sense-compute-interact rounds
to continuously evaluate the “spatiotemporal boundary”
of the process/ensemble.
Therefore, we may conclude that often
the macro-program is a piece of behaviour
that is used to parameterize
a larger behaviour,
supported by a proper runtime system or middleware,
which provides the “basic principle”
for the collection of micro-level entities
to act as a system.

Behavioural concerns
that can be abstracted
include specific decisions
(e.g., what data must be stored or propagated),
processing operations,
and time aspects
(e.g., when a certain behaviour is to be executed).
For instance, in SNAP <cit.>,
the individual switches
must determine how to route traffic and
where the place state variables.
As another example, macro-programs in aggregate computing <cit.>,
abstract from scheduling aspects,
which enables dynamic tuning
of the frequency at which devices operate, making time a “fluid” notion in such systems <cit.>.

Interactional concerns
are also often abstracted.
In many cases, indeed, the details of communication,
such as the specific format of the messages,
the specific set of recipients,
can be determine at runtime.
approaches for WSN, for instance,
generally provide abstractions
over routing
and hop-by-hop information flows.

Among implementation strategies,
a number of patterns recur
The macroprogram
as in PIECES <cit.> or STOP/Chronus <cit.>,
instruct mobile agents
to move across the nodes of the network
to access and process local state
to infer global information.
Orchestration – cf. Dolphin <cit.> and SmartSociety <cit.> – is similar
but does not involve
moving agents.
Related is also
the approach, used for instance in Pyot <cit.>,
based on inferring tasks from the macroprogram
and distributing them over the set of micro-level entities.
Round-based execution of macro-programs or projected micro-programs is also frequent and
can be found
both in asynchronous variants,
as in aggregate computing <cit.>,
and in synchronous variants
as in Giraph++ <cit.>, SOSNA <cit.>,
and WOSP <cit.>.
Such implementation strategies,
beside “filling the abstraction gap”,
are also aimed at optimising application-specific concerns,
which may include
saving resources (e.g., energy or bandwidth)
or promoting Quality of Service metrics like latency or reliability.

Number of core works per approach category.

Number of core works per paradigm.

Number of works per host platform/language. The (*) means that multiple languages are supported.

Number of core works per micro-level dependency level.

Number of core works per macro-to-micro mapping approach.

Collected data about technical aspects of the surveyed  approaches.

§.§ Opportunities

Research on
provides opportunities (with corresponding challenges, covered in <Ref>)
in terms of synergies with related research fields
and application domains.

§.§.§ Model- and Language-based Software Engineering

as abstract representations of some aspect of a real or imagined object,
play a key role in software engineering <cit.>.
Systems are generally described through multiple models
covering different perspectives or viewpoints <cit.>.
As covered in <Ref>,
macroscopic perspectives
can be instrumental
for directly addressing
global properties, collective tasks, or system-level aspects.
Indeed, we can observe that prominent perspectives
in software modelling
(e.g., structure, behaviour, and interaction)
can be considered at a microscopic or a macroscopic level.
For the latter:

* The macro-structural view considers the structural arrangement of multiple components of a system.
The creation of macro-structures is sometimes a goal of  (cf. topology programming in Pleiades <cit.>).

* The macro-behavioural view considers behaviours emerging from multiple components of a system. This is generally the goal of : expressing the behaviour of a system as a whole (cf. swarm  in Buzz <cit.>).

* The macro-interactional view considers interaction and communication at increasingly non-local levels. This is often instrumental to drive macro-behaviour by expressing how information flows among several components or across large structures (cf. collective communication interfaces in Abstract Regions <cit.>).

Models have to be expressed in some language (also called a meta-model).
Languages exist for specification,
and verification of software,
and contribute to a vision of language-based software engineering <cit.>,
which promotes the use of high-level DSLs
for building software.
Related notions such as
goal-oriented <cit.>
declarative programming <cit.>
are used to denote a similar idea:
the use of languages
to express an abstract model of a system
emphasising what has to be achieved rather than how.
The benefit is that the complexity for efficiently mapping the what
to the how can be encapsulated in a middleware layer,
while application developers can focus on domain abstractions and the business logic.
In this sense,
can be considered as a particular domain of declarative programming;
however, we think that research in this field
can potentially provide insights
on the general principles and foundations of declarative programming.

§.§.§ Intelligent middlewares

Beside expressiveness,
the abstraction provided by
can foster the implementation
of smart solutions at the middleware level.
In early  approaches on WSNs,
the goal was often simplifying the programming activity (i.e., productivity)
while keeping performance overhead at acceptable levels.
In time,
the idea of actually improving performance
started to be considered as a research goal.
Indeed, overfitting solutions may not be able
to adequately generalise their performance
to the various situations a system may experience in practice.
On the other hand,
more abstract architectures
could adapt to diverse situations
and do that opportunistically—by proactively looking for opportunities of optimisation.
Of course, there is a trade-off between overfitting and underfitting models, and this revolves around a careful design of  solutions in terms of (domain-specific) assumptions.

The middleware could be the part of the software system
that implements the global-to-local mapping logic,
possibly in a smart way.
Such a smartness could serve to
avoid unnecessary computations or communications,
change structure to promote functionality, or
re-configure the application to improve performance or resiliency.
For instance,
in aggregate computing <cit.> and MacroLab <cit.>,
the logical macro-programmed system can be deployed
variously on available infrastructure,
where different deployments may result in different
non-functional trade-offs;
moreover, their middleware can in principle adapt the deployment
opportunistically as infrastructure, user preferences, or environmental conditions change.
Indeed, a key opportunity would be to leverage
recent advances in self-adaptive software
and autonomic computing
as well as artificial intelligence and machine learning.

it is interesting to note,
in certain  approaches,
the particular interplay between
the language (and hence the programs)
the middleware.
For instance, in aggregate computing <cit.>,
the programs do not express control flow
and the programmer rather assumes
the program to be collectively played by the system of devices
through a
“self-organisation-like execution protocol”.
As mentioned earlier, this provides opportunities
in terms of flexibility
in the implementation and deployment
of the actual execution protocol <cit.>.
The point is how much these results can be generalised
into design principles and patterns:
this is a research opportunity (with corresponding challenges—see <Ref>)
related to the (relationship between the) design of declarative programming languages
and the design of intelligent middlewares for corresponding applications.

§.§.§ Collective Intelligence, Soft Computing, Social Computing

The recent techno-scientific trends
and visions (cf. pervasive and ubiquitous computing, the IoT etc.)
let us foresee an ever-increasing, world-wide deployment
of devices capable of computation and communication.
Reasoning just in terms of individual devices
would hardly allow us to fully harness “the power of the collective”.
On the other hand,
adopting a vision of “cyber-physical collectives and ecosystems”
could provide a further perspective
for better addressing socio-technical
services and applications.
There are several systems
that are amenable to be studied and engineered
by a collective perspective,
as well as several research fields that
address aspects of such collective systems <cit.>.
Works on  are often found in such research areas (see <Ref> and <Ref>),
and might contribute (from its construction-oriented perspective)
to the overall research endeavour
about collective systems.

Computational collective intelligence (CCI)
is a sub-field of AI
that focusses on
“the form of intelligence that emerges from the collaboration
and competition of many individuals (artificial and/or natural)” <cit.>.
The affinity with  is evident,
as the latter generally provides a means
for expressing what collective intelligent behaviour
should be like or work at,
encapsulating the logic for building it
in terms of rules of individual behaviour and interaction.
the abstraction provided by strong  languages
tends to favour implementations
achieving approximated solutions
in complex situations.
This is especially evident in  languages
for collective adaptive systems (<Ref>),
such as aggregate computing <cit.>,
where macro-programs express
global outcomes that are to be sought progressively
in a self-organising fashion.
In this sense,
promotes a language-based approach
to soft computing <cit.>, namely
the use of computing to approximately solve very complex problems
despite uncertainty, perturbations, and partial knowledge.

A recent systematic literature review
on “collective intelligence” <cit.>,
covers conceptual frameworks and models
for “collaborative problem solving and decision making”, in the broad sense of social computing <cit.>—namely the paradigm where humans, society, and computing technology integrate to promote information representation, processing, communication, and use.
The survey focusses on a high-level view
and purposefully abstracts from specific domains—not even mentioned, the programming viewpoint is completely neglected.
However,  DSLs could work as inter-disciplinary artifacts
capturing relationship and behaviour
of groups and ecosystems.
Benefits could be obtained by addressing issues at the right perspective.

§.§ Challenges

There are a number of challenges
related to
the engineering of  systems.
These include, e.g.,
designing macro-level abstractions,
bridging macro-level abstractions with micro-level activity,
formalising the macro-to-micro mapping logic,
providing formal guarantees about the correctness of such a mapping,
and integrating  systems with
more traditional programming environments.

§.§.§ Abstraction and global-to-local mapping

A key challenge in
is defining a good, coherent set of macro-level abstractions
and identifying a proper way to map those
to micro-level activity while promoting
both functional and non-functional requirements.
This also includes finding a balance
between over-fitting and under-fitting solutions:
the former may hinder reusability
and extensibility,
while the latter,
as an attempt to achieve a one-size-fits-all support,
may complicate implementations.
As discussed previously,
effective, highly-productive programming
and smartness in implementations
is where the most opportunities  arise
and arguably the major concerns for any  language.
The challenge revolves around
ensuring that global-to-locally mapped behaviour
results, when actually carried out, in local-to-global effects
in a consistent (and possibly efficient) way.

Implementing proper global-to-local mapping logic
is a key challenge in any  system.
This is related to what Tumer and Wolpert call the inverse problem in COIN (COllective Intelligence) <cit.>, i.e., configuring the laws of a system such that the desired collective behaviour is generated
[However, the COIN approach aims to steer macro-behaviour by merely setting the local utility functions of reinforcement learning agents: this can hardly be seen as strong  since no macro-level abstraction is used. According to the proposed terminology (<Ref>), this can instead be seen as a weak form of , or meso-programming.].
The difficulty of this problem
is one of the reasons that
make it hard to
find specific designs or solutions for  in general:
domain goals set peculiar global requirements,
domain assumptions are often instrumental
for effective mapping of abstractions
down to the underlying “platform”.
Still, the observation of regularities, namely “patterns”,
can provide for useful hints
to both the theory and practice of .

Moreover, some  approaches
such as, e.g., DEECo <cit.>, SCEL <cit.>,
and aggregate programming <cit.>,
target complex/collective adaptive systems <cit.>—see <Ref>.
Such systems feature complex networks of interactions
that typically result in emergent properties (emergents) <cit.>,
namely macro-level properties that cannot be easily traced back to micro-level activity, because they are not – by definition – the result of mere summation of individual contributions (i.e., they are based on non-linear dynamics) <cit.>.
Due to its very nature,
promoting desired emergents
is a challenge.
However, in some cases, emergence can be “steered”.
Existing research <cit.> seems to suggest that
may provide a privileged perspective and approach
for steering emergent behaviour
towards the desired emergents.
In a sense,
the development of a  system
might force its designers
to approach the problem
by a mixed top-down/bottom-up strategy.

§.§.§ Formal approaches to

In software engineering,
the use of formal methods
enables specification of non-ambiguous models of systems
and promote their analysis and verification, possibly automated.
In ,
languages backed by formal theories and calculi
may be analysed
to verify qualitative or quantitative properties.
For instance,
in aggregate programming
it has been possible,  by considering its core language (the field calculus),
to prove Turing-like universality for space-time computations,
identify language fragments supporting self-stabilising
and density-independent computations,
prove optimality theorems for specific algorithms or encodings,
and promote deployment-independence at the middleware level <cit.>.
In SCEL <cit.>,
statistical model checking tools can be used to
verify reachability properties, i.e.,
to compute the probability that a certain system configuration
(e.g., expressed as a predicate on collected information)
is reached within a certain deadline.
Vice versa,
several other  languages
focus mainly on providing a high-level API,
simplifying the programming activity
but providing little support for analysis and verification.
In some cases,
the semantics of the DSL is not even specified formally.
Other approaches,
such as WOSP <cit.>,
provide certain properties (e.g., low communication overhead)
by construction and
use empirical methods (e.g., simulation) for verification.
a challenge related to the identification of good abstractions
and global-to-local mapping strategies
is the definition of formal frameworks
supporting both correct and efficient implementations
as well as discovery of properties and results
(both at the application and middleware level).
We note that this challenge (and opportunity)
is also recognised by other fields of research
including self-adaptive software
and robotics threads <cit.>.

Besides applying formal methods
for verification and analysis
within specific  systems,
another challenge
lies in devising a
general, formal theory of
that abstracts from specific languages
and possibly even from concrete paradigms.
One possibility
would be to rigorously identify
a minimal but complete set
of concepts or predicates
applicable to programming systems
to classify them as (a form of) .
The basic principles provided in <Ref>
could make for a starting point in this research.
The use of such a formal framework
could then be used to
provide alternative, possibly more precise, classifications
of  approaches
with respect to the one provided in <Ref>.

§.§.§ Heterogeneity

A system is heterogeneous if it comprises
different kinds of components.
a system of multiple heterogeneous components or individuals
is challenging because
making use of the different capabilities of these
requires an individual-level viewpoint.
Vice versa,  homogeneous collectives
(such as swarms of homogeneous robots)
tends to be simpler
as any robot is assimilable to another.
In principle,
heterogeneity may be abstracted
at the programming level
and encapsulated at the middleware level,
or code may be organised such that
specific behaviour is modularised.
We also remark that homogeneity and heterogeneity are not sharp characteristics but form a continuum,
and that abstraction makes things more homogeneous,
by removing unnecessary details (possibly including differences and peculiarities).

Moreover, heterogeneity
is not only in shape or capabilities
but also in aspects
like autonomy and programmability.
For instance,
consider a heterogeneous cyber-physical collective
made of smart city components (e.g., smart traffic lights, cloudlets, autonomous vehicles)
and augmented human operators (e.g., through smartphones, smart watches or glasses),
which may be programmed to support decentralised crowdsensing applications;
the digital devices worn by those humans
will move according to those humans' deliberation,
and hence their mobility could not be programmed
(but only “requested”, at best).
Among the surveyed approaches, only
the SmartSociety platform <cit.>
provides some support for human orchestration,
where humans and machines are considered peers.

While collectives tend to be homogeneous,
heterogeneity is typically more present in
composites, namely collections of entities
related by a notion of componenthood <cit.>.
An example is a car, which builds on components such as engine, wheels, etc. However,
it would be very hard to imagine the possibility of programming a car as a whole.

To conclude this reflection,
does not need to assume homogeneity,
but it does need to take heterogeneity into account
at some level of its engineering stack (middleware, application, model).
Moreover, we also observe that
is not to be thought as a comprehensive approach
meant to define all aspects of a system behaviour,
which also leads to the following challenge.

§.§.§ Integration with other programming paradigms and toolchains

As discussed in previous sections,

embodies a particular viewpoint of system development,
which may not capture all the relevant
functional and non-functional requirements.
Indeed, a complex system
may involve the solution of multiple different problems,
each one best addressed by a specific paradigm.
This is the idea of multi-paradigm programming <cit.>.
On a more pragmatic side,
on top of existing development platforms
(such as the JVM or .NET)
may enable quick prototyping
as well as reuse of features and tools from the host platform.
This has fostered the emergence of internal DSLs <cit.> for ,
which are embedded as expressive APIs
on top of existing general-purpose languages:
this is the case of
PyoT (Python) <cit.>,
Chronus (Ruby) <cit.>,
jDEECo (Java) <cit.>,
ScaFi for aggregate programming (Scala) <cit.>,
Dolphin (Groovy) <cit.>,
D'Artagnan (Haskell) <cit.>, and
AErlang (Erlang) <cit.>.
this aspect of integration of paradigms
poses architectural challenges,
especially considering that
tends to permeate various dimensions
of the system—including structure, behaviour, and interaction.
In summary,
multi-paradigm programming
is appealing
but must be carefully
at the level
of models,
and development practice.

§ RELATED WORK

This work integrates, extends upon, and
differentiates with respect to other survey papers.
The main difference is that the secondary studies presented in the following,
while similarly rich and detailed,
adopt a narrower perspective (spatial computing, WSN, microelectromechanical systems, and swarm robotics, respectively).
By contrast, this survey aims to relate various  approaches across disparate domains, and adopts a general software engineering viewpoint.
Moreover, due to their publication time, other surveys only cover works published before 2012.
Indeed, by analysing the twenty-year time-frame from early 2000s to 2020,
we can also make considerations about trends (see <Ref>).

The most related survey is <cit.>, which however focusses on spatial computing languages.
It proposes a conceptual framework where
spatial computation can be described
in terms of constructs for
(i) measuring space-time (sensors);
(ii) manipulating space-time (actuators);
(iii) computation;
(iv) physical evolution (inherent spatiotemporal dynamics).
The device model accounts for the way devices are discretised in space-time (distinguishing between discrete, cellular, and continuous models),
the way they are programmed (e.g., by giving them a uniform programs, heterogeneous programs, or leveraging mobile code),
their communication scope (e.g., through local, neighbourhood, global regions), and
their communication granularity (e.g., unicast, multicast, or broadcast).
The survey classifies languages in the following groups:
(i) amorphous computing (including pattern languages and manifold programming languages);
(ii) biological modelling;
(iii) agent-based modelling (including multi-agent and distributed systems modelling);
(iv) wireless sensor networks
(distinguishing between region-based, dataflow-based, database abstraction-based, centralised-view, and agent-based languages);
(v) pervasive computing;
(vi) swarm and modular robotics;
(vii) parallel and reconfigurable computing
(including dataflow, topological, and field languages);
(viii) formal calculi for concurrency and distribution
(i.e., process algebras/calculi).
Languages are further analysed based on:
characteristics of the language (type, DSL implementation pattern, platform, layers),
supported spatial computing operators,
abstract device characteristics. Language type ranges over functional, imperative, declarative, graphical, process calculus, and any.

Very related is also <cit.>,
a 2011 survey that covers programming approaches for wireless sensor networks.
In their taxonomy,
the interaction pattern
is classified into (i) one-to-many,
(ii) many-to-one,
(iii) many-to-many.
the extent of distributed processing in space
can be
(i) global, e.g., in environment monitoring applications; or
(i) regional, e.g., in intrusion detection or HVAC systems in buildings.
Other dimensions include goal (sense-only or sense-and-react),
mobility (static, mobile),
time (periodic or event-driven).
Regarding WSN programming abstractions, they define a taxonomy as follows.
Communication aspects cover:
scope (system-wide, physical neighbourhood-based, or multi-hop group);
addressing (physical or logical);
and awareness (implicit or explicit).
Computation aspects include scope of computation (local, group, or global).
The model of data access could be database, data sharing, mobile code, or message passing.
Finally, the paradigm could be:
imperative (sequential or event-driven);
declarative (functional, rule-based, SQL-like, special-purpose); or hybrid.

The survey <cit.>
on distributed intelligent microelectromechanical systems (MEMS) programming also provides a classification based on the
distinction between device-level and system-level programming models.
The surveyed programming models are then analysed w.r.t. the characteristics of
real-time support, application range (general-purpose vs. domain-specific),
syntax complexity, scalability, mobility support, and uncertainty tolerance.

The review <cit.>
of swarm robotics from an engineering perspective
neglects the programming viewpoint.
However, they provide a taxonomy where
collective behaviour is classified into
behavior for
(i) spatial organisation (e.g., pattern formation, morphogenesis),
(ii) navigation and mobility (e.g., coordinated motion and transport),
(iii) collective decision making (e.g., consensus achievement and task allocation),
(iv) other.
Design methods are categorised into behaviour-based (e.g., finite state machines, virtual physics-based)
and automatic (e.g., evolutionary robotics and reinforcement learning-based methods).
Analysis methods are categorised into microscopic models, macroscopic models (e.g., via rate/differential equations or control/stability theory), and real-robot analysis.

Finally, certain works proposed concepts useful for
classifying and understanding  approaches.
These elements have been considered and integrated into the taxonomy provided in <Ref>.
A possible classification of macroprogramming approaches <cit.> distinguishes between

* node-dependent macroprogramming—where the nodes (or, more generally, the components of the micro-level) and their states are referred to explicitly by the macroprogram; and

* node-independent macroprogramming—where the  underlying nodes are not visible at all to the programmer.

As per the discussion of <Ref>,
node-dependent approaches tend to enact a weak form of .
Examples of node-independent approaches include, e.g., those that abstract a WSN as a database.
Another distinction can be made between:

* data-driven macroprogramming <cit.>—where macro-programs define tasks consuming and producing data; and

* control-driven macroprogramming <cit.>—where macro-programs specify control flow and instructions operating on distributed memory.

The classification in data-driven and control-driven approaches has been applied in other fields such as coordination <cit.>, where the latter are also known as task- or process-oriented coordination models.

§ CONCLUSION

This paper provides, for the first time,
an explicit, integrated view of research
on  languages.
It discusses what  is,
its core application domains,
its main concepts,
and analyses and classifies
a wide range of works
addressing system development
by a more-or-less macroscopic perspective.
We argue that such a high-level stance
could be beneficial
for software engineering
in forthcoming distributed computing scenarios (cf. IoT, CPS, smart ecosystems)
and for promoting language-based solutions
to collective adaptive behaviour and intelligence.
In particular,
the macro-level perspective could represent a complementary viewpoint
for addressing structure, behaviour, and interaction in complex systems.
approaches tend to be
domain-specific, because domain assumptions
are generally instrumental to properly and efficiently
map high-level abstractions to activity on the low-level platform.
However, there is arguably margin for
recovering general principles
through inter-domain discussion and sharing of ideas,
but this requires a more integrated and structured view
of  as a field, which this article aims to cultivate.

Missing 'biblatex' package
The bibliography requires the 'biblatex' package.

journaltitleAI Mag.
titleMultiagent Systems: A Modern Approach to Distributed Artificial Intelligence

journaltitleJ. Symb. Comput.
titleOperational semantics for declarative multi-paradigm languages

University of California Press

seriesSociology (University of California)
titleThe Micro-macro Link

booktitleProceedings of the 30th ACM Symposium on Applied Computing
titleA calculus for attribute-based communication

titleNetKAT: semantic foundations for networks

journaltitleSoftw. Pract. Exp.
titleA Survey of Systems Programming Languages: Concepts and Facilities

titleSNAP: Stateful Network-Wide Abstractions for Packet Processing

booktitle2007 IEEE/RSJ International Conference on Intelligent Robots and Systems, October 29 - November 2, 2007, Sheraton Hotel and Marina, San Diego, California, USA
titleMeld: A declarative approach to programming ensembles

journaltitleComput. Networks
titleThe Internet of Things: A survey

IEEE Computer Society

booktitle11th IEEE International Conference on Self-Adaptive and Self-Organizing Systems, SASO 2017, Tucson, AZ, USA, September 18-22, 2017
titleCompositional Blocks for Optimal Self-Healing Gradients

booktitleProceedings of the 2007 EuroSys Conference, Lisbon, Portugal, March 21-23, 2007
titleMacroprogramming heterogeneous sensor networks using COSMOS

booktitleProceedings of the 9th IEEE International Symposium on Industrial Embedded Systems, SIES 2014, Pisa, Italy, June 18-20, 2014
titlePyoT, a macroprogramming framework for the Internet of Things

journaltitleNeural Comput. Appl.
titleComposable continuous-space programs for robotic swarms

journaltitleTheor. Comput. Sci.
titleA brief history of process algebra

IEEE Computer Society

titleArchetype-based design: Sensor network programming for application experts, not just programming experts

booktitleProceedings of the 2005 workshop on End-to-end, sense-and-respond systems, applications and services
titleThe abstract task graph: a methodology for architecture-independent programming of networked sensor systems

seriesLecture Notes in Computer Science
titleProgramming Paradigms for Networked Sensing: A Distributed Systems' Perspective

booktitleA 25-Year Perspective on Logic Programming: Achievements of the Italian Association for Logic Programming, GULP
seriesLecture Notes in Computer Science
titleAgents, Multi-Agent Systems and Declarative Programming: What, When, Where, Why, Who, How?

journaltitleIEEE Intelligent Systems
titleInfrastructure for Engineered Emergence in Sensor/Actuator Networks

titleOrganizing the Aggregate: Languages for Spatial Computing

titleAggregate Programming for the Internet of Things

journaltitleComput. Commun. Rev.
titleDon't mind the gap: Bridging network-wide objectives and device-level configurations: brief reflections on abstractions for network programming

journaltitleSci. Comput. Program.
titleMulti-agent oriented programming with JaCaMo

IEEE Computer Society

booktitle48th Annual IEEE/IFIP International Conference on Dependable Systems and Networks, DSN 2018, Luxembourg City, Luxembourg, June 25-28, 2018
titlePleiades: Distributed Structural Invariants at Scale

journaltitleSwarm Intell.
titleSwarm robotics: a review from the swarm engineering perspective

IOS Press

booktitleFormal Ontology in Information Systems: Proceedings of the 11th International Conference (FOIS 2020)
titlePluralities, collectives, and composites

Wiley Online Library

journaltitleSoftware: Practice and Experience
titleThe fractal component model and its support in java

booktitleCBSE'13, Proceedings of the 16th ACM SIGSOFT Symposium on Component Based Software Engineering, part of Comparch '13, Vancouver, BC, Canada, June 17-21, 2013
titleDEECO: an ensemble-based component system

booktitleProceedings of the 16th European Symposium on Programming Languages and Systems (ESOP)
titleStructured global programming for communication behaviour

journaltitleACM SIGPLAN Notices
titleGlobal Computation

journaltitleFuture Internet
titlePulverization in Cyber-Physical Systems: Engineering the Self-Organizing Logic Separated from Deployment

booktitleLeveraging Applications of Formal Methods, Verification and Validation: Engineering Principles - 9th International Symposium on Leveraging Applications of Formal Methods, ISoLA 2020, Proceedings, Part II
seriesLecture Notes in Computer Science
titleFScaFi : A Core Calculus for Collective Adaptive Systems Programming

journaltitleEng. Appl. Artif. Intell.
titleEngineering collective intelligence at the edge with aggregate processes

IEEE Computer Society

booktitleIEEE International Conference on Wireless and Mobile Computing, Networking and Communications, WiMob 2008, Avignon, France, 12-14 October 2008, Proceedings
titleA System for Using Wireless Sensor Networks as Globally Deductive Databases

journaltitleInt. J. Distributed Sens. Networks
titleLogic Macroprogramming for Wireless Sensor Networks
seriesDagstuhl Seminar Proceedings
titleComputing Media and Languages for Space-Oriented Computation, 03.09. - 08.09.2006

journaltitleTheor. Comput. Sci.
titleA core model for choreographic programming

booktitleProceedings of the 9th International Conference on Embedded Networked Sensor Systems, SenSys 2011, Seattle, WA, USA, November 1-4, 2011
titleProgramming micro-aerial vehicle swarms with karma
family=De Nicola,

journaltitleInt. J. Softw. Tools Technol. Transf.
titleRigorous engineering of collective adaptive systems: special section

booktitleProceedings of the 11th PErvasive Technologies Related to Assistive Environments Conference, PETRA 2018, Corfu, Greece, June 26-29, 2018
titleA Framework for Programming a Swarm of UAVs

IEEE Computer Society

booktitle32nd IEEE International Conference on Advanced Information Networking and Applications, AINA 2018, Krakow, Poland, May 16-18, 2018
titlePICO-MP: De-centralised Macro-Programming for Wireless Sensor and Actuator Networks

IEEE Computer Society

booktitle29th Annual IEEE Conference on Local Computer Networks (LCN 2004), 16-18 November 2004, Tampa, FL, USA, Proceedings
titleContiki - A Lightweight and Flexible Operating System for Tiny Networked Sensors

booktitleIntegrated Formal Methods - 14th International Conference, IFM 2018, Proceedings
seriesLecture Notes in Computer Science
titleRobotics and Integrated Formal Methods: Necessity Meets Opportunity

Osaka, Japan

booktitleAdjunct Proceedings of the 2015 ACM International Joint Conference on Pervasive and Ubiquitous Computing and Proceedings of the 2015 ACM International Symposium on Wearable Computers
seriesUbiComp/ISWC'15 Adjunct
titleCollective Adaptive Systems
collective adaptive systems,pervasive computing,self-organization,superorganism,wearable computing

booktitleProceedings of the 2020 ACM Conference on Innovation and Technology in Computer Science Education, ITiCSE 2020
titleCapturing and Characterising Notional Machines

journaltitleInt. J. Softw. Eng. Knowl. Eng.
titleViewpoints: A Framework for Integrating Multiple Perspectives in System Development

journaltitleTheor. Comput. Sci.
titleA new framework for declarative programming

Wiley Online Library

journaltitleSystem Dynamics Review
titleI keep six honest serving men: they taught me all I knew

journaltitleEcological Complexity
titleEmergence and complex systems: The contribution of dynamic graph theory

journaltitleComput. Commun. Rev.
titleNOX: towards an operating system for networks

booktitleDistributed Computing in Sensor Systems, First IEEE International Conference, DCOSS 2005, Marina del Rey, CA, USA, June 30 - July 1, 2005, Proceedings
seriesLecture Notes in Computer Science
titleMacro-programming Wireless Sensor Networks Using Kairos

journaltitleSci. Comput. Program.
titleLanguage-based software engineering

titleNano-CF: A coordination framework for macro-programming in Wireless Sensor Networks

seriesCognitive Systems Monographs
titleSpace-Time Continuous Models of Swarm Robotic Systems - Supporting Global-to-Local Programming

Raleigh, NC, USA

Association for Computing Machinery

abstractWe present a macroprogramming framework called MacroLab that offers a vector programming abstraction similar to Matlab for Cyber-Physical Systems (CPSs). The user writes a single program for the entire network using Matlab-like operations such as addition, find, and max. The framework executes these operations across the network in a distributed fashion, a centralized fashion, or something between the two - whichever is most efficient for the target deployment. We call this approach deployment-specific code decomposition (DSCD). MacroLab programs can be executed on mote-class hardware such as the Telos [24] motes. Our results indicate that MacroLab introduces almost no additional overhead in terms of message cost, power consumption, memory footprint, or CPU cycles over TinyOSprograms.
booktitleProceedings of the 6th ACM Conference on Embedded Network Sensor Systems
seriesSenSys '08
titleMacroLab: A Vector-Based Macroprogramming Framework for Cyber-Physical Systems
programming abstractions,macroprogramming,embedded networks,cyber-physical systems

titleA relaxed synchronization primitive for macroprogramming systems

Oxford University Press

seriesEmergence: From Chaos to Order
titleEmergence: From Chaos to Order

titleWhen does a physical system compute?

journaltitleInt. J. Agent Oriented Softw. Eng.
titleDeveloping organised multiagent systems using the MOISE\({}^{\mbox{+}}\) model: programming issues at the system and agent levels

booktitle3rd IEEE European Conference on Smart Sensing and Context (EuroSSC), IEEE Communications Society, Zurich
titleStructuring sensor networks with scopes

journaltitleIEEE Trans. Syst. Man Cybern. Part C
titleMorphogenetic Robotics: An Emerging New Field in Developmental Robotics

journaltitleJ. Organ. Comput. Electron. Commer.
titleEmergence phenomena in self-organizing systems: a systematic literature review of concepts, researches, and future prospects

titleOptimizing the "one big switch" abstraction in software-defined networks

booktitleProceedings of the 5th Workshop on Data Management for Sensor Networks, in conjunction with VLDB, DMSN 2008, Auckland, New Zealand, August 24, 2008
seriesACM International Conference Proceeding Series
titleStream-based macro-programming of wireless sensor, actuator network applications with SOSNA

booktitleHandbook of Nature-Inspired and Innovative Computing - Integrating Classical Models with Emerging Technologies
titleSwarm Intelligence

titleThe Vision of Autonomic Computing

booktitleInternational Workshop on Reflection and Meta-Level Architecture
titleTowards a new model of abstraction in the engineering of software

journaltitleJust so stories
titleI keep six honest serving men

Keele University
Durham University Joint Report

abstractThe objective of this report is to propose comprehensive guidelines for systematic literature reviews appropriate for software engineering researchers, including PhD students. A systematic literature review is a means of evaluating and interpreting all available research relevant to a particular research question, topic area, or phenomenon of interest. Systematic reviews aim to present a fair evaluation of a research topic by using a trustworthy, rigorous, and auditable methodology. The guidelines presented in this report were derived from three existing guidelines used by medical researchers, two books produced by researchers with social science backgrounds and discussions with researchers from other disciplines who are involved in evidence-based practice. The guidelines have been adapted to reflect the specific problems of software engineering research. The guidelines cover three phases of a systematic literature review: planning the review, conducting the review and reporting the review. They provide a relatively high level description. They do not consider the impact of the research questions on the review procedures, nor do they specify in detail the mechanisms needed to perform meta-analysis.
numberEBSE 2007-001
titleGuidelines for performing Systematic Literature Reviews in Software Engineering

titleTeCoLa: A Programming Framework for Dynamic and Heterogeneous Robotic Teams

journaltitleProc. IEEE
titleSoftware-Defined Networking: A Comprehensive Survey

Cambridge University Press, Cambridge

journaltitleThe Cambridge Handbook of Computing Education Research
titleProgramming paradigms and beyond

booktitleCoordination Models and Languages - 17th IFIP WG 6.1 International Conference, COORDINATION 2015, Held as Part of the 10th International Federated Conference on Distributed Computing Techniques, DisCoTec 2015, Grenoble, France, June 2-4, 2015, Proceedings
seriesLecture Notes in Computer Science
titleComingle: Distributed Logic Programming for Decentralized Mobile Ensembles

booktitleSoftware Engineering for Self-Adaptive Systems II - International Seminar, Dagstuhl, Revised Selected and Invited Papers
seriesLecture Notes in Computer Science
titleSoftware Engineering for Self-Adaptive Systems: A Second Research Roadmap

booktitleAmbient Intelligence
titleTinyOS: An Operating System for Sensor Networks

journaltitleACM Comput. Surv.
titleDistributed Intelligent MEMS: A Survey and a Real-Time Programming Framework

journaltitleSoft Comput.
titleSurvey on soft computing

journaltitleACM Comput. Surv.
titleA Survey of Metaprogramming Languages

booktitleOn the Move to Meaningful Internet Systems 2006: CoopIS, DOA, GADA, and ODBASE 2006. Proceedings, Part II
seriesLecture Notes in Computer Science
titleA Case for Event-Driven Distributed Objects

titleDolphin: A Task Orchestration Language for Autonomous Vehicle Networks

journaltitleAdapt. Behav.
titleSocial Situatedness of Natural and Artificial Intelligence: Vygotsky and Beyond

journaltitleIEEE Pervasive Comput.
titleState-Centric Programming for Sensor-Actuator Network Systems

booktitle1994 Joint Conference on Declarative Programming, GULP-PRODE 1994, Volume 1
titlePractical Advtanages of Declarative Programming

titlePractical advantages of declarative programming

booktitleProceedings of the ACM SIGMOD International Conference on Management of Data, Chicago, Illinois, USA, June 27-29, 2006
titleDeclarative networking: language, execution and optimization

family=De Nicola,

booktitleFormal Methods for the Quantitative Evaluation of Collective Adaptive Systems - 16th International School on Formal Methods for the Design of Computer, Communication, and Software Systems, SFM 2016, Bertinoro, Italy, June 20-24, 2016, Advanced Lectures
seriesLecture Notes in Computer Science
titleModelling and Analysis of Collective Adaptive Systems with CARMA and its Tools

journaltitleInform. Forsch. Entwickl.
titleModels in software engineering - an introduction

booktitleWorkshop on Mobile Computing and Systems Applications
titleSupporting Aggregate Queries Over Ad-Hoc Wireless Sensor Networks

booktitleACM SIGOPS European Workshop
titleUsing virtual markets to program global behavior in sensor networks

booktitleProceeding of the 13th ACM SIGPLAN international conference on Functional programming, ICFP 2008, Victoria, BC, Canada, September 20-28, 2008
titleFlask: staged functional programming for sensor networks

journaltitleACM Trans. Auton. Adapt. Syst.
titleMacro Programming a Spatial Computer with Bayesian Networks

journaltitleIEEE Pervasive Comput.
titleCo-Fields: A Physically Inspired Approach to Motion Coordination

booktitleCyber-physical systems
titleNetwork-wide programming challenges in cyber-physical systems

booktitleProceedings of the Real World Domain Specific Languages Workshop 2018
titleD'Artagnan: An embedded DSL framework for distributed embedded systems

titlePorthos: Macroprogramming Blockchain Systems

Springer Publishing Company, Incorporated

abstractThis pioneering text provides a comprehensive introduction to systems structure, function, and modeling as applied in all fields of science and engineering. Systems understanding is increasingly recognized as a key to a more holistic education and greater problem solving skills, and is also reflected in the trend toward interdisciplinary approaches to research on complex phenomena. While the concepts and components of systems science will continue to be distributed throughout the various disciplines, undergraduate degree programs in systems science are also being developed, including at the authors own institutions. However, the subject is approached, systems science as a basis for understanding the components and drivers of phenomena at all scales should be viewed with the same importance as a traditional liberal arts education. Principles of Systems Science contains many graphs, illustrations, side bars, examples, and problems to enhance understanding. From basic principles of organization, complexity, abstract representations, and behavior (dynamics) to deeper aspects such as the relations between information, knowledge, computation, and system control, to higher order aspects such as auto-organization, emergence and evolution, the book provides an integrated perspective on the comprehensive nature of systems. It ends with practical aspects such as systems analysis, computer modeling, and systems engineering that demonstrate how the knowledge of systems can be used to solve problems in the real world. Each chapter is broken into parts beginning with qualitative descriptions that stand alone for students who have taken intermediate algebra. The second part presents quantitative descriptions that are based on pre-calculus and advanced algebra, providing a more formal treatment for students who have the necessary mathematical background. Numerous examples of systems from every realm of life, including the physical and biological sciences, humanities, social sciences, engineering, pre-med and pre-law, are based on the fundamental systems concepts of boundaries, components as subsystems, processes as flows of materials, energy, and messages, work accomplished, functions performed, hierarchical structures, and more. Understanding these basics enables further understanding both of how systems endure and how they may become increasingly complex and exhibit new properties or characteristics. Serves as a textbook for teaching systems fundamentals in any discipline or for use in an introductory course in systems science degree programs Addresses a wide range of audiences with different levels of mathematical sophistication Includes open-ended questions in special boxes intended to stimulate integrated thinking and class discussion Describes numerous examples of systems in science and society Captures the trend towards interdisciplinary research and problem solving
titlePrinciples of Systems Science

O'Reilly Media, Inc.

abstractVirtualization, cloud, containers, server automation, and software-defined networking are meant to simplify IT operations. But many organizations adopting these technologies have found that it only leads to a faster-growing sprawl of unmanageable systems. This is where infrastructure as code can help. With this practical guide, author Kief Morris of Thought Works shows you how to effectively use principles, practices, and patterns pioneered through the DevOps movement to manage cloud age infrastructure. Ideal for system administrators, infrastructure engineers, team leads, and architects, this book demonstrates various tools, techniques, and patterns you can use to implement infrastructure as code. In three parts, youll learn about the platforms and tooling involved in creating and configuring infrastructure elements, patterns for using these tools, and practices for making infrastructure as code work in your environment. Examine the pitfalls that organizations fall into when adopting the new generation of infrastructure technologies Understand the capabilities and service models of dynamic infrastructure platforms Learn about tools that provide, provision, and configure core infrastructure resources Explore services and tools for managing a dynamic infrastructureLearn specific patterns and practices for provisioning servers, building server templates, and updating running servers
titleInfrastructure as Code: Managing Servers in the Cloud

titleTeam-level programming of drone sensor networks

journaltitleACM Comput. Surv.
titleProgramming wireless sensor networks: Fundamental concepts and state of the art

journaltitleIEEE Trans. Software Eng.
titlemakeSense: Simplifying the Integration of Wireless Sensor Networks into Business Processes

booktitleProceedings of the 6th International Conference on Information Processing in Sensor Networks, IPSN 2007, Cambridge, Massachusetts, USA, April 25-27, 2007
titleThe regiment macroprogramming system

seriesACM International Conference Proceeding Series
titleRegion streams: functional macroprogramming for sensor networks

journaltitleACM SIGPLAN Notices
titleProgramming ad-hoc networks of mobile and resource-constrained devices

journaltitleSci. Comput. Program.
titleAErlang: Empowering Erlang with attribute-based communication

journaltitleACM Trans. Auton. Adapt. Syst.
titleA Formal Approach to Autonomic Systems Programming: The SCEL Language

booktitleProceedings of the International Conference on Internet of Things Design and Implementation, IoTDI 2019, Montreal, QC, Canada, April 15-18, 2019
titleDDFlow: visualized declarative programming for heterogeneous IoT networks

booktitleECOOP'97 - Object-Oriented Programming, 11th European Conference, Jyväskylä, Finland, June 9-13, 1997, Proceedings
seriesLecture Notes in Computer Science
titleGOODS to Appear on the Stage

journaltitleAdv. Comput.
titleCoordination Models and Languages

journaltitleIEEE Trans. Computers
titleEnergy-Efficient Task Mapping for Data-Driven Sensor Network Macroprogramming

booktitleTheoretical Aspects of Distributed Computing in Sensor Networks
seriesMonographs in Theoretical Computer Science. An EATCS Series
titleHigh-Level Application Development for Sensor Networks: Data-Driven Approach

titleTime-Fluid Field-Based Coordination through Programmable Distributed Schedulers

journaltitleFuture Gener. Comput. Syst.
titlePartitioned integration and coordination via the self-organising coordination regions pattern

booktitleProceedings of the 30th Annual ACM Symposium on Applied Computing, Salamanca, Spain, April 13-17, 2015
titleProtelis: practical aggregate programming

journaltitleIEEE Softw.
titleBuzz: A Programming Language for Robot Swarms

booktitleProceedings of the 9th EAI International Conference on Bio-inspired Information and Communications Technologies (formerly BIONETICS)
titleA tuple space for data sharing in robot swarms

booktitle2013 MTS/IEEE OCEANS-Bergen
titleThe LSTS toolchain for networked vehicle systems

titleThingNet: A micro-service based IoT macro-programming platform over edges and cloud

journaltitleIEEE Access
titleDigital Twin: Values, Challenges and Enablers From a Modeling Perspective

booktitleProceedings of the 8th ACM SIGOPS European Workshop: Support for Composing Distributed Applications 1998
titleGoal-oriented programming, or composition using events, or threads considered harmful

IEEE / ACM

booktitleProceedings of the 6th International Conference on Mobile Software Engineering and Systems, MOBILESoft@ICSE 2019, Montreal, QC, Canada, May 25, 2019
titleWarble: programming abstractions for personalizing interactions in the internet of things

journaltitleIEEE Trans. Emerg. Top. Comput.
titleA Programming Model for Hybrid Collaborative Adaptive Systems

booktitleMulti-Agent-Based Simulation, Second International Workshop, MABS 2000, Revised and Additional Papers
seriesLecture Notes in Computer Science
titleThe Micro-Macro Link in DAI and Sociology

titleThe Cyber-Physical Systems Revolution

University of Virginia

titleThe Design of MDB: a Macrodebugger for Wireless Embedded Networks

booktitleProgramming Languages and System Architectures, International Conference, Proceedings
seriesLecture Notes in Computer Science
titleLanguage and Architecture Paradigms as Object Classes

booktitleJoel on Software
titleThe law of leaky abstractions

journaltitleACM Trans. Sens. Networks
titleProgramming models for sensor networks: A survey

journaltitleACM Comput. Surv.
titleFrameworks for Collective Intelligence: A Systematic Literature Review

seriesWiley Series on Parallel and Distributed Computing
titleComputational Collective Intelligence

World Scientific Publishing Co., Inc.

booktitleCurrent Trends in Theoretical Computer Science: Entering the 21st Centuary
titleTowards Global Computations Guided by Concurrency Theory

journaltitleProc. VLDB Endow.
titleFrom "Think Like a Vertex" to "Think Like a Graph"

titleEcoCast: Interactive, object-oriented macroprogramming for networks of ultra-compact wireless sensor nodes

titleCollectives and the Design of Complex Systems

journaltitleCommun. ACM
titleA Bridging Model for Parallel Computation

IRCAM/Delatour France

journaltitleNew computational paradigms for computer music
titleProgramming paradigms for dummies: What every programmer should know

IOP Publishing

journaltitleBioinspiration & Biomimetics
titleA swarm design paradigm unifying swarm behaviors using minimalistic communication

journaltitleJ. Log. Algebraic Methods Program.
titleFrom distributed coordination to field calculus and aggregate computing

titleDSL Engineering - Designing, Implementing and Using Domain-Specific Languages

booktitleProceedings of the 16th International Conference on Computer Communications and Networks, IEEE ICCCN 2007, Turtle Bay Resort, Honolulu, Hawaii, USA, August 13-16, 2007
titleA SpaceTime Oriented Macroprogramming Paradigm for Push-Pull Hybrid Sensor Networking

IEEE Computer Society

titleMacroprogramming Spatio-temporal Event Detection and Data Collection in Wireless Sensor Networks: An Implementation and Evaluation Study

Academic Press

journaltitleAutonomic Network Management Principles: From Concepts to Applications
titleChronus: A spatiotemporal macroprogramming language for autonomic wireless sensor networks

journaltitleACM Comput. Surv.
titlePartitioned Global Address Space Languages

booktitleInternational Workshop on Mobile Object Systems
titleA note on distributed computing

journaltitleIEEE Intell. Syst.
titleSocial Computing: From Social Informatics to Social Intelligence

journaltitleACM Comput. Surv.
titleA Survey of Multitier Programming

booktitle1st Symposium on Networked Systems Design and Implementation (NSDI 2004), Proceedings
titleProgramming Sensor Networks Using Abstract Regions

booktitle5th International C* Conference on Computer Science & Software Engineering, C3S2E 2012
titleA survey of formal methods in self-adaptive systems

Boston, MA, USA

booktitle2nd International Conference on Mobile systems, applications, and services
titleHood: a neighborhood abstraction for sensor networks

seriesLecture Notes in Computer Science
titleSemantic Streams: A Framework for Composable Semantic Interpretation of Sensor Data

booktitleEngineering Self-Organising Systems, Methodologies and Applications [revised versions of papers presented at the Engineering Selforganising Applications (ESOA 2004) workshop, held during the Autonomous Agents and Multi-agent Systems conference (AAMAS 2004) in New York in July 2004, and selected invited papers]
seriesLecture Notes in Computer Science
titleEmergence Versus Self-Organisation: Different Concepts but Promising When Combined

titleAn Introduction to MultiAgent Systems, Second Edition

journaltitleJ. Syst. Archit.
titleAll one needs to know about fog computing and related edge computing paradigms: A complete survey

journaltitleBus. Process. Manag. J.
titleA systematic literature review on BPMN extensions

journaltitleIEEE Trans. Robotics
titleEvolved and Designed Self-Reproducing Modular Robotics