Search

Collective adaptive systems are collections of autonomous, possibly heterogeneous devices which cooperate towards a common goal. This class of systems is often proposed as a way to engineer complex distributed systems, with applications ranging from the Internet of Things and smart cities, to swarm robotics. To the best of our knowledge, however, security issues are often overlooked or mixed with safety concerns. In this paper, we look at the current work in security for collective adaptive systems. By viewing the most fundamental security patterns and principles through the lens of collective adaptive systems, we identify the most prominent challenges and differences with respect to traditional security methods, paving the way to more in-depth analysis to be carried on in future works.

The objective of this paper is to present the vision and structure of Fluidware, an approach towards an innovative programming model to ease the development of flexible and robust large-scale IoT services and applications. The key distinctive idea of Fluidware is to abstract collectives of devices of the IoT fabric as sources, digesters, and targets of distributed “flows” of contextualized events, carrying information about data produced and actuating commands. Accordingly, programming of services and applications relies on declarative specification of “funnel processes” to channel, elaborate, and re-direct such flows in a fully-distributed way, as a means to coordinate the activities of devices and realize services and applications. The potential applicability of Fluidware and its expected advantages are exemplified via a case study scenario in the area of ambient assisted living.

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 interaction. 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 processes. We describe this model and a prototype implementation in the ScaFi aggregate programming framework, which is rooted in the so-called computational field paradigm.

Aggregate Computing is a promising paradigm for coordinating large numbers of possibly situated devices. It is used, in particular, in scenarios related to the Internet of Things, smart cities, drone fleet coordination, and mass urban events. Currently, however, little work has been devoted to study and improve security in aggregate programs. Existing works only focus on application-level countermeasures, typically introducing trust metrics to detect misbehaving devices. Those security systems work under the assumption that the underlying computational model is respected; however, so-called Byzantine behaviour violates such assumption. In this paper, we discuss how Byzantine behaviours can hinder an aggregate program, and exploit application-level protection for creating bigger disruption. We discuss how the Blockchain technology can mitigate these attacks by enforcing behaviours consistent with the expected operational semantics, with no impact on the application logic.

The impressive development of wearable computing and augmented/mixed reality technologies that has been occurring in recent years allows for devising ICT systems that can bring a disruptive innovation in how emergency medical operations take place. In this paper the authors describe first explorations in that direction, represented by a distributed collaborative system called SAFE (Smart Augmented Field for Emergency) for teams of rescuers and operators involved in a rescue mission. SAFE is based on the integration of wearable computing and augmented reality technologies with intelligent agents and multi-agent systems.

The complexity of large-scale distributed systems, particularly when deployed in physical space, calls for new mechanisms to address composability and reusability of collective adaptive behaviour. Computational fields have been proposed as an effective abstraction to fill the gap between the macro-level of such systems (specifying a system's collective behaviour) and the micro-level (individual devices' actions of computation and interaction to implement that collective specification), thereby providing a basis to better facilitate the engineering of collective APIs and complex systems at higher levels of abstraction. This paper proposes a full formal foundation for field computations, in terms of a core (higher-order) calculus of computational fields containing a few key syntactic constructs, and equipped with typing, denotational and operational semantics. Critically, this allows formal establishment of a link between the micro- and macro-levels of collective adaptive systems, by a result of full abstraction and adequacy for the (aggregate) denotational semantics with respect to the (per-device) operational semantics., 39 pages, 12 figures

The formal modelling of programming languages has always been a challenging activity due to the gap occurring between formal definition and actual implementation. On the other hand, the Maude rewriting language has already proven to be a suitable tool to bridge the gap between theory and practice when implementing the operational semantics of programming languages. In particular, Maude has been exploited to model languages belonging to different paradigms and levels of abstraction, leading to specifications that represent de facto executable prototypes of such languages.In this paper we focus on A&A ReSpecT, a coordination language based on the agents and artifacts (A&A) meta-model, and exploit Maude to generate an execution machine for A&A ReSpecT programs, acting as an implementation of its operational semantics.

We present the design of a BPEL orchestration engine based on ReSpecT tuple centres, a coordination model extending Linda with the ability of declaratively programming the reactive behaviour of tuple spaces. Architectural and linguistic aspects of our solution are discussed, focussing on how the syntax and semantics of BPEL have been mapped to tuple centres. This is achieved by a translation of BPEL specifications to set of logic tuples, and conceiving the execution cycle of the orchestration engine in terms of ReSpecT reactions.

In this paper we propose a simulation framework specifically suited for developmental biology studies. It is mainly composed of three parts. First, it is based on a multiscale computational model, and related logic-oriented specification language compiler, supporting large-scale networks of compartments and an enhanced model of chemical reactions addressing molecule transfer. Second, we rely on a simulation engine based on an optimised version of the Gillespie stochastic simulation algorithm, which is able to simulate fine events at intracellular and multicellular level. Third, a metaheuristic-based module for automatically calibrating model parameters (such as reaction rates) is exploited. As a case study we model the first stages of Drosophila melanogaster development, which generate the early spatial pattern of gap gene expression. Results show the formation of a precise spatial pattern which has been successfully compared with observations acquired from the real embryo gene expressions. In particular, adopting the Covariance Matrix Adaptation Evolution Strategy for parameter estimation is crucial for the quality of the results achieved, reducing the error of a 60% from the initial formulation of parameters. The main contribution of this paper is the enhancement of a stochastic, multi-compartment simulator by means of a metaheuristic-based module for parameter estimation. This is the first such application available in literature, where the subject of parameter estimation is well-established only for deterministic single-compartment models. Moreover this is the first work demonstrating the ability of the Gillespie stochastic simulation algorithm, when properly equipped with additional parameter optimisation techniques, to model large-scale, complex biological systems.

Formal models, core calculi, and type systems, are important tools for rigorously stating the more subtle details of a language, as well as characterizing and studying its features and the correctness properties of its programs. In this paper we present FAAL (Featherweight Agent and Artifact Language), a formal calculus modelling the agent and artifact program abstractions provided by the simpA agent framework. The formalisation is largely inspired by Featherweight Java. It is based on reduction rules applied in certain evaluation contexts, properly adapted to the concurrency nature of simpA. On top of this calculus we introduce a standard type system and prove its soundness, so as to guarantee that the execution of a well-typed program does not get stuck. Namely, all primitive mechanisms of agents (activity execution), artifacts (field/property access and step execution), and their interaction (observation and invocation) are guaranteed to be used in a way that is structurally compliant with the corresponding definitions: hence, there will not be run-time errors due to FAAL distinctive primitives

Starting from the pioneering work on Lindaand Gamma, coordination models and languages have gone through an amazing evolution process over the years. From closed to open systems, from parallel computing to multi-agent systems and from database integration to knowledge-intensive environments, coordination abstractions and technologies have gained in relevance and power in those scenarios where complexity has become a key factor. In this paper, we outline and motivate 25 years of evolution of coordination models and languages, and discuss their potential perspectives in the future of artificial systems.

Target counting is an established challenge for sensor networks: given a set of sensors that can count (but not identify) targets, how many targets are there? The problem is complicated because of the need to disambiguate duplicate observations of the same target by different sensors. A number of approaches have been proposed in the literature, and in this paper we take an existing technique based on Euler integration and develop a fully-distributed, self-stabilising solution. We derive our algorithm within the field calculus from the centralised presentation of the underlying integration technique, and analyse the precision of the counting through simulation of several network configurations. Postprint

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

P@J is a framework, based on the tuProlog open-source engine, allowing Prolog code to be used as possible implementation of a Java method: Java annotations are used for specifying all the necessary information to fill the Java-Prolog gap. This framework is useful to inject a declarative, logic-based paradigm into mainstream object-oriented programming, so as to easily code functionalities related to automatic reasoning, adaptivity, and conciseness in expressing algorithms. In this paper, an extension of P@J is presented which improves the invocation technique for such Prolog-implemented methods. Java type inference of generic method calls is intensively used to automatically infer all the necessary paradigm mismatch information: this results in an elegant and concise invocation style, which further reduces the gap between Prolog goal satisfaction and Java method invocation. This new approach inspires some interesting applications: we show examples related to the implementation of abstract data types and parsers for context-free grammars.

This paper describes a Java-based framework for the development of component-based software systems supporting the specification of the logic of component interactions as a first-class aspect. Java is used as the reference development language.On the one side, the framework makes it possible to specify the logic of interaction at the component-level, in terms of input and output interfaces, the events generated and observed by a component, and related information about the management of the control flow. On the other side, it is possible to specify the logic of interaction at the inter-component level, providing a modelling and linguistic support for designing and (dynamically) programming the glue among the components, enabling general forms of observation, control and construction of the interaction space.As a result, the framework supports the coordination of components at different levels: from interoperability among heterogeneous and unknown components, to the support for dynamic introduction, removal and update of components, to general coordination patterns, such as workflow. The framework adopts first-order logic as the reference computational model for describing and defining the logic of interaction: the modalities adopted by components to interact, the coordination laws gluing the components and the interaction events occurring in the system are expressed as facts and rules. They compose the (evolving) logic theories describing and defining the interaction at the system level, and can be observed and controlled at runtime to allow dynamic re-configurability.

A key feature for infrastructures providing coordination services is the ability to define the behaviour of coordination abstractions according to the requirements identified at design-time. We take as a representative for this scenario the logic-based language ReSpecT (Reaction Specification Tuples), used to program the reactive behaviour of tuple centres. ReSpecT specifications are at the core of the engineering methodology underlying the TuCSoN infrastructure, and are therefore the “conceptual place” where formal methods can be fruitfully applied to guarantee relevant system properties.In this paper we introduce ReSpecT nets, a formalism that can be used to describe reactive behaviours that can succeed and fail, and that allows for an encoding to Petri nets with inhibitor arcs. ReSpecT nets are introduced to give a core model to a fragment of the ReSpecT language, and to pave the way for devising an analysis methodology including formal verification of safety and liveness properties. In particular, we provide a semantics to ReSpecT specifications through a mapping to ReSpecT nets. The potential of this approach for the analysis of ReSpecT specifications is discussed, presenting initial results for the analysis of safety properties.

In order to address open, distributed, and knowledge-intensive scenarios, we introduce a semantic-oriented extension of the tuple centre coordination model. There, each tuple centre is extended with the ontological description of the coordination domain, expressed by means of the W3C standard OWL. Unlike existing approaches in the literature, our coordination model smoothly extends the standard syntactic setting of tuple spaces, allowing tuple centres to encapsulate the semantic representation of the domain of discourse, and to embody semantic coordination policies. In order to test the feasibility of our approach, a prototypical implementation of our model in the TuCSoN infrastructure featuring the Pellet semantic reasoner is described and discussed.

The impressive development of technologies is reducing the gulf between the physical and the digital matter, reality and virtuality. Mirror worlds MW are agent-based systems that live on this edge. They are meant to be a conceptual blueprint for designing future smart environment systems, providing an innovative conceptual framework for investigating inter-disciplinary aspects --- from cognition to interaction, cooperation, governance --- concerning human-agent mixed-reality and augmented systems. In this paper we focus on the problem of how to concretely design and program mirror worlds, in particular adopting high-level programming abstractions that are provided by state-of-the-art agent-oriented programming models and technologies.

More and more the engineering of complex agent-based systems calls for infrastructural support for coordination and security issues integrated with services for the description and management of system organisation. This trend is evident in the state-of-the-art models adopted for the man- agement of security and organisation of complex information systems: in this context Role-Based Access Control (RBAC) models are emerging as a reference architecture for integrating security issues – access control in particular – and (role-based) organisation management. In this paper we discuss how an RBAC-like model has been fruitfully exploited to extend an infrastructure for the coordination of agent-based systems – TuCSoN – with the support for organisation and security management, in particular as far as access control is concerned.

The self-organisation Gradient pattern is known to be a key spatial data structure to make information local to its source become global knowledge, and to dynamically and adaptively steer agents to that source even in mobile and faulty environments – e.g. when obstacles unpredictably appear. In this paper we conceive new self-organisation mechanisms built upon this pattern to tackle anticipative adaptation. We ensure that the retrieval of a target of interest proactively reacts to locally-available information about future events, namely, the knowledge about future obstacles (e.g., expected jams or road interruption in a traffic control scenario) is used to emergently compute alternative and faster paths.

Open and distributed application scenarios like e-Health systems mandate for new coordination models and technologies. In particular, they require middleware providing coordination and security services modelled with abstractions promoting run-time observability and adaptation. Along this line, in this paper we describe the architecture of the TuCSoN coordination infrastructure, and show its application to an e-Health application scenario.

Our research moves from three fundamental considerations that concern the modelling and engineering of complex systems. First, organization, coordination and security are strictly related issues that should be modelled in a uniform and coherent framework. Second, models, technologies and methodologies should come hand in hand, so that abstractions used in the analysis and design stages should be still “alive and kicking” at development and execution time. Third, the general non-formalisability of complex systems should not prevent us from using formal tools whenever useful, such as in proving or ensuring properties of limited but meaningful portions of a system. By focussing on multi-agent systems, we discuss the notion of Agent Coordination Context (ACC) as an abstraction that (i) works as an organization and security abstraction, (ii) integrates well with abstractions provided by coordination infrastructures, and (iii) covers the engineering process from design to deployment. In particular, in this paper we study the syntax and semantics of a language for ACCs specification, exploiting typical process algebra techniques. Accordingly, we show that process algebras are a suitable tool for both specification and enactment of security and coordination policies through ACCs.

We show how a formal framework for the observation issue in computer systems can be used for the specification of an agent behavior, abstracting away from agent inner details while focusing on its interactive behavior. This model can also be used as a specification of agent communication languages (ACLs), providing the proper abstraction level to represent the conditions causing an agent to send a message, as well as its effect on the receiving agent. In particular, this approach generalizes upon existing ACL semantics, such as FIPA ACL, that relate agent communicative acts to the agent mental state. Since the observation framework induces a more abstract architecture than other known approaches, our semantics are likely to be applicable to a wider set of agent architectures, thus better supporting standardization aims. Some application examples are shown, describing how various aspects of ACL semantics can be specified within our framework.

Interaction represents one of the main sources of complexity in Multi-agent Systems (MAS). As a consequence, coordination — as the management of the space of system interaction — plays a key role in the engineering of MAS. In this context, the tuple centre coordination abstraction have been experimented in MAS to manage interaction among agents and between agents and MAS environment. Along this line, the aim of this paper is to test the expressive power of tuple centres as the unifying abstractions to model and govern the whole range of admissible interactions within a MAS. For this purpose, we take the notion of Agent Coordination Context (ACC) — aimed at supporting interaction between an individual agent and the MAS as a whole — and show how it can be implemented in terms of a tuple centre in a MAS infrastructure. In particular, we adopt ReSpecT tuple centres as the coordination abstractions and TuCSoN as the coordination infrastructure managing the space of interaction in a MAS, and provide an example of how the TuCSoN ACC can be implemented by means of a suitably-programmed ReSpecT tuple centre.

More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, as a result of several factors, such as the widespread availability of multi-core / parallel architectures and Internet-based systems. Java has been one of the first mainstream languages providing a first-class native support for multi-threading, with basic low level fine-grained concurrency mechanisms. Besides this fine-grained support to concurrency, the identification of higher-level---more coarse-grained---support is important as soon as programming and engineering complex concurrent applications is considered, helping to bridge the gap between system design, implementation and testing. Accordingly, in this paper we present simpA, a library-based extension of Java which introduces a high-level coarse-grained support to prototyping complex, multi-threaded / concurrent applications: Java programmers are provided with an agent-oriented abstraction layer on top of the basic OO layer to organize and structure applications.

Much recent work in the design of object-oriented programming languages has been focusing on identifying suitable features to support so-called scalable extensibility , where the usual extension mechanism by inheritance works in different scales of software components-that is, classes, groups of classes, groups of groups and so on. Its typing issues has usually been addressed by means of dependent type systems, where nested types are seen as properties of objects. In this work, we seek instead for a different solution, which can bemore easily applied to Java-like languages, in which nested types are considered properties of classe. We introduce the mechanism of variant path types , which provide a flexible means to express intra-group relationship (among classes) that has to be preserved through extension. In particular, improving and extending existing works on groups and exact types, we feature the new notions of exact and inexact qualifications , providing rich abstractions to express various kinds of set of objects, with a flexible subtyping scheme. We formalize a safe type system for variant path types on top of Feather weight Java. Our development results in a complete solution for scalable extensibility, similarly to previous attempts based on dependent type systems.

Although object-oriented languages are nowadays the mainstream of application development, several research contexts suggest that a multi-paradigm approach is worth pursuing. In particular, a declarative, logic-based paradigm could fruitfully add functionalities related to automatic reasoning, adaptivity, and conciseness in expressing algorithms. In this paper we present P@J, a framework for enhancing interoperability between Java and Prolog based on the tuProlog open-source Prolog engine for Java. P@J supports smooth language-interoperability by first introducing an API for modeling first-order logic terms by Java generics and wildcards, promoting expressiveness and safety. On top of it, an annotation layer is then introduced that extends Java with the ability of implementing parts of the application code using Prolog.

We develop the mechanism of variant parametric types as a means to enhance synergy between parametric and inclusion polymorphism in object-oriented programming languages. Variant parametric types are used to control both the subtyping between different instantiations of one generic class and the accessibility of their fields and methods. On one hand, one parametric class can be used to derive covariant types, contravariant types, and bivariant types (generally called variant parametric types) by attaching a variance annotation to a type argument. On the other hand, the type system prohibits certain method/field accesses, according to variance annotations, when these accesses may otherwise make the program unsafe. By exploiting variant parametric types, a programmer can write generic code abstractions that work on a wide range of parametric types in a safe manner. For instance, a method that only reads the elements of a container of numbers can be easily modified so as to accept containers of integers, floating-point numbers, or any subtype of the number type.Technical subtleties in typing for the proposed mechanism are addressed in terms of an intuitive correspondence between variant parametric and bounded existential types. Then, for a rigorous argument of correctness of the proposed typing rules, we extend Featherweight GJ---an existing formal core calculus for Java with generics---with variant parametric types and prove type soundness.

Family polymorphism has been proposed for object-oriented languages as a solution to supporting reusable yet type-safe mutually recursive classes. A key idea of family polymorphism is the notion of families, which are used to group mutually recursive classes. In the original proposal, due to the design decision that families are represented by objects, dependent types had to be introduced, resulting in a rather complex type system. In this article, we propose a simpler solution oflightweightfamily polymorphism, based on the idea that families are represented by classes rather than by objects. This change makes the type system significantly simpler without losing much expressive power of the language. Moreover, “family-polymorphic” methods now take a form of parametric methods; thus, it is easy to apply method type argument inference as in Java 5.0. To rigorously show that our approach is safe, we formalize the set of language features on top of Featherweight Java and prove that the type system is sound. An algorithm for type inference for family-polymorphic method invocations is also formalized and proved to be correct. Finally, a formal translation by erasure to Featherweight Java is presented; it is proved to preserve typing and execution results, showing that our new language features can be implemented in Java by simply extending the compiler.

Java wildcards is a new programming mechanism shipped with the Java 5.0 release, introduced to provide a flexible subtyping mechanism for generic types. Safety is retained by providing rather peculiar and non-trivial mechanisms to restrict access to a class functionalities (methods and fields), which are currently not deeply described in the Java Language Specification. In this paper we develop on the theory of variant parametric types from which wildcards originated, and study a framework to describe these access restriction issues in detail, promoting the understanding and fruitful exploitation of this new programming concept. Our work is both technical and conceptual. On the one hand, we provide an abstract characterisation of formal rules to access restriction, then instantiated to the particular implementation of wildcards in current Java. On the other hand, we show that such a characterisation induces a natural description and understanding of access restriction in terms of the ability of (instances of) a generic class to produce/consume elements of the abstracted type.

Variant parametric types [8] have been introduced to provide a flexible subtyping mechanism for generic types, and are recently being developed into Java wildcards [15], shipped worldwide with the JDK 1.5 release. The two approaches, which are strictly related, retain safety by providing rather peculiar and non-trivial mechanisms to restrict access to a class functionalities (methods and fields). In this paper we aim at studying a unified framework to describe this issue in detail, and to facilitate the understanding and exploitation of this new programming concept.Our work is both technical and conceptual. On the one hand, we provide formal rules to access restriction and specialise them for the two approaches, so as to emphasise similarities and differences. On the other hand, we show that such rules promote a natural description and understanding of access restriction in terms of the ability of (instances of) a generic class to produce/consume elements of the abstracted type.

In this paper we evaluate transition systems as a tool for providing a rule-based specification of the operational aspects of autonomous agents. By our technique, different aspects of an agent can be analyzed and designed in a loosely coupled way, enabling the possibility of studying their properties in isolation. We take as a use case the Parade framework for building intelligent agents, which leverages a FIPA-like ACL semantics to support semantic interoperability. Our grey-boxing technique is exploited to provide a specification where aspects related to the ACL, the adopted ontology, the agent social role, and the other agent internal details are described separately, in an incremental way.

The Proto spatial computing language in Beal and Bachrach (2006) [1] simplifies the creation of scalable, robust, distributed programs by abstracting a network of locally communicating devices as a continuous geometric manifold. However, Proto's successful application in a number of domains is challenging its coherence across different platforms and distributions. We thus present a complete operational semantics for the Proto language, as executed asynchronously on a network of fast message-passing devices. This semantics covers all of the operations of the three space-time operator families unique to Proto-restriction, feedback, and neighborhood-as well as the current pointwise operations that it shares with most other languages. This formalization will provide a reference to aid implementers in preserving language coherence across platforms, domains, and distributions. The formalization process has also advanced the Proto language in several ways, which we explain in detail.

The possibility to have millions of computational devices interconnected across urban environments opens up novel application areas. In such highly distributed scenarios, applications must gain awareness as a result of opportunistic encounters with co-located devices, a departure from traditional reasoning approaches. We envision situated awareness as an emergent property of such networks, where bio-inspired algorithms are employed to coordinate interactions between devices through managing the lifecycle, distribution, and content of data. A congestion-aware, crowd-steering example illustrates this vision.

The goal of this work is the proposal of a language for programming coordination artifacts, providing a better level of abstraction than than achieved via imperative programming languages. We propose a declarative logic language based on reactive rules to define coordination artifacts implementing both well-known and novel coordination paradigms. A prototype built on top of CArtAgO, and relying on the tuProlog Prolog engine, is also presented, where different coordination paradigms realized upon the language are shown.

This article introduces the notion of environment programming in software Multi-Agent Systems (MAS) and describes a concrete computational and programming model based on the artifact abstraction and implemented by the CArtAgO framework. Environment programming accounts for conceiving the computational environment where agents are situated as a first-class abstraction for programming MAS, namely a part of the system that can be designed and programmed - aside to agents - to encapsulate functionalities that will be exploited by agents at runtime. From a programming and software engineering perspective, this is meant to improve the modularity, extensibility and reusability of the MAS as a software system. By adopting the A&A meta-model, we consider environments populated by a dynamic set of computational entities called artifacts, collected in workspaces. From the agent viewpoint, artifacts are first-class entities of their environment, representing resources and tools that they can dynamically instantiate, share and use to support their individual and collective activities. From the MAS programmer viewpoint, artifacts are a first-class abstraction to shape and program functional environments that agents will exploit at runtime, including functionalities that concern agent interaction, coordination, organisation, and the interaction with the external environment. The article includes a description of the main concepts concerning artifact-based environments and related CArtAgO technology, as well as an overview of their application in MAS programming.

In this chapter, we focus on the need for innovative open pervasive middleware infrastructures to support self-organisation, self-adaptation and evolvability, in distributed applications, with a particular attention to pervasive computing scenarios. We discuss how such middleware infrastructures should be at the basis of a nature-inspired architectural approach to system design, enabling the modelling and the deployment of services as autonomous individuals in an ecosystem of other services, data sources, and pervasive devices interacting with one another. A reference conceptual architecture is presented to clarify the concepts expressed and the role of middleware within it, and several possible approaches to realise the idea are surveyed and critically analysed, also with the help of a simple case study. Two concrete examples of middleware infrastructures—namely the TOTA (Tuples On The Air) middleware supporting a physically-inspired computing model and the TuCSoN (Tuple Centres over the Network) middleware supporting a chemical-inspired one—are detailed along with examples showing how to use such infrastructures.

PurposeEmerging pervasive computing scenarios require open service frameworks promoting situated and self‐adaptive behaviors, and supporting diversity in services and long‐term evolvability. This suggests adopting a nature‐inspired approach, where pervasive services are modeled and deployed as autonomous individuals in an ecosystem of other services, data sources, and pervasive devices. However, there are many possibly nature‐inspired metaphors that can be adopted, and choosing one may require a careful analysis of the pros and cons of the different metaphors. The purpose of this paper is to analyze the key requirements and desiderata for next generation pervasive computing services and associated infrastructures.Design/methodology/approachIn this paper, the authors introduce and critically analyze a number of natural metaphors that can be adopted to realize these concepts and survey relevant proposals in the area.FindingsThe key result of this survey is that a uniform reference architecture can be a useful guide when framing the challenges involved in the design and implementation of future self‐adaptive pervasive service ecosystems.Originality/valueThe survey in this paper, along with the proposed reference architecture, can be effective starting points towards the definition and implementation of general‐purpose nature‐inspired pervasive service ecosystems.

A library-based extension of Java, the simpA framework, introduced a new abstraction based on agent-oriented concepts. Agents are autonomous entities that cooperate by exploiting artifacts, representing resources that are dynamically created and shared by agents. In this paper we present a core calculus integrating techniques coming from the area of concurrency and from OO programming. The syntax of the calculus with its static and dynamic semantics are introduced through an example. The calculus aims to foster the formalization (and proof) of type soundness of simpA programs and the development of techniques for analyzing the computational behaviour of agents and artifacts.

The Proto spatial computing language [6] simplifies the creation of scalable, robust, distributed programs by abstracting a network of locally communicating devices as a continuous geometric manifold. However, Proto's successful application in a number of domains is becoming a challenge to its coherence across different platforms and distributions. We thus present an operational semantics for a core subset of the Proto language. This semantics covers all the key operations of the three space-time operator families unique to Proto---restriction, feedback, and neighborhood---as well as a few of the pointwise operations that it shares with most other languages. Because Proto programs are distributed, we also present an operational semantics for their asynchronous execution across a network. This formalization will provide a reference to aid implementers in preserving language coherence across platforms, domains, and distributions.

Agent modularisation is a main issue in agent and multi- agent system programming. Existing solutions typically propose con- structs such as capabilities to group and encapsulate in well-defined mod- ules inside the agent different kinds of agent features, that depend on the architecture or model adopted—examples are goals, beliefs, inten- tions, skills. In this paper we introduce a further perspective, which can be considered complimentary to existing approaches, which accounts for externalizing some of such functionalities into the computational envi- ronment where agents are (logically) situated. This leads to some benefits in terms of reusability, dynamic extensibility and openness. To this end, we exploit artifact-based computational environments as introduced by the A&A meta-model and implemented in CArtAgO technology: agent modules are realised as suitably designed artifacts that agents can dy- namically exploit as external tools to enhance their action repertoire and – more generally – their capability to execute tasks. Then, to let agent (and agent programmers) exploit such capabilities abstracting from the low-level mechanics of artifact management and use, we exploit the dual notion of internalization, which consists in dynamically consulting and automatically embedding high-level usage protocols described in artifact manuals as agent plans. The idea is discussed providing some practi- cal examples of use, based on CArtAgO as technology for programming artifacts and Jason agent platform to program the agents.

With the goal of addressing open and dynamic scenarios like the Web, in this paper we introduce a semantic-oriented extension of the tuple space model. In our model, each tuple space is equipped with the ontological description of the coordination domain (e.g. expressed in W3C's OWL language). Tuples represent individuals of the domain along with their properties, and retrieval templates correspond to queries used to check whether an individual is the instance of an ontological concept (as typical in Description Logics, the logic of semantic reasoning). Differently from existing approaches in literature, we obtain a model that is fully expressive -- compared to OWL -- with a smooth extension of the standard syntactic setting of tuple spaces, namely, by an intuitive extension of the language for tuples and tuple templates. We discuss an incarnation of this model in the TuCSoN coordination model and infrastructure.

This paper aims at pushing the clear relationship between software service composition and chemical dynamics a step forward. We developed a coordination model where services and clients are coordinated via a tuple space handling services as if they were interacting chemical substances: on the one hand, services get equipped with an "activity value" resembling chemical concentration and measuring their reactiveness as imposed by the tuple space; on the other hand, services automatically compose via interaction ports resembling chemical bonding. The tuple space enacts a feedback loop that regulates and balances the activity level of (atomic or composite) services, decreasing it over time as in chemical decay, but reinforcing it each time the service is correctly used. This behaviour promotes service competition: losing (i.e. unused) services literally extinguish. Which services or service compositions survive competition is automatically decided solely based on resulting performance, i.e. the rate at which services are actually exploited.

A crucial aspect of managing data-centric and pervasive networks is the design of proper self-organizing data-distribution approaches, including aggregation, collection, diffusion, and so on.In this paper we introduce the collective sort problem for network environments that aims at collecting and segregating data by similarity. Data is collected and segregated in localized areas of the network selected by an emergent process.A solution to the problem is analyzed for a coordination scenario featuring a grid-like distributed set of Linda tuple spaces and a set of sorting agents executing a probabilistic protocol resembling brood collection in ant colonies.Based on simulation, we show how patterns of data collection emerge in spite of the very basic observation and computation abilities of sorting agents.

More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, as a result of several factors, such as the widespread availability of multi-core / parallel architectures and Internet-based systems. Java has been one of the first mainstream languages providing a first-class native support for multi-threading, with basic low-level fine-grained concurrency mechanisms, recently improved by means of the java.util.concurrent library provided in the JDK 5.0. Besides such a fine-grained support to concurrency, the identification of higher-level - more coarse-grained - support is important as soon as the programming and engineering of complex concurrent applications is considered, helping to bridge the gap between system design, implementation, or testing. Accordingly, in this paper we present simpA, a library-based extension of Java which aims at providing a high-level coarse-grained support to complex multithreaded / concurrent application programming, by providing Java programmers with an agent-oriented abstraction layer on top of the basic OO layer to organise and structure applications in terms of agents and artifacts.

This paper describes CArtAgO, a framework for developing artifact-based working environments for multiagent systems (MAS). The framework is based on the notion of artifact, as a basic abstraction to model and engineer objects, resources and tools designed to be used and manipulated by agents at run-time to support their working activities, in particular the cooperative ones. CArtAgO enables MAS engineers to design and develop suitable artifacts, and to extend existing agent platforms with the possibility to create artifact-based working environments, programming agents to exploit them. In this paper, first the abstract model and architecture of CArtAgO is described, then a first Java-based prototype technology is discussed.

Providing runtime information about generic types---that is, reifying generics---is a challenging problem studied in several research papers in the last years. However, the quest for finding effective and efficient solutions specifically targeted to the Java programming language is still open. In particular, the new mechanism of wildcards introduced in Java 5.0 significantly complicates the overall semantics of generics: its reification aspects are currently unexplored and pose serious implementation issues. In this paper we analyse such issues and study how they have been supported in the context of the EGO compiler. EGO is an approach for efficiently supporting runtime generics at compile-time in Java: synthetic code is automatically added to the source code by the compiler, so as to create generic runtime type information on a by-need basis, store it into object instances, and retrieve it when necessary in type-dependent operations. We show how the design of EGO has been completely and successfully extended to represent wildcard types, and how we deal with subtle issues concerning subtyping, capture conversion and wildcards capture in method calls.

In contrast to standard approaches based on agent communication languages (ACLs), environment-based coordination is emerging as an interesting alternative for structuring interactions in multiagent systems (MASs). In particular, the notion of coordination artifacts has been proposed as an engineering methodology to build runtime abstractions effectively providing collaborating agents with specifically designed coordination tasks.In this paper, we study the semantics for the interaction of agents with coordination artifacts playing the same role of ACL semantics, that is, supporting semantic interoperability between agents developed by different parties through the connection between rationality and interaction. Our approach is rooted on the notion of operating instructions of coordination artifacts, which—as with a manual for a human exploiting a device—describe the interaction protocols the agent can follow as well as the mentalistic semantics of each single interaction. By tackling some of the most relevant issues raised in the context of ACL semantics, our framework allows intelligent, BDI-like agents to carry on complex interactions through coordination artifacts in a rational way.