Loris Penserini

Towards goal-oriented development of self-adaptive systems

Self-adaptive software aims at anticipating changes which occur in a complex environment and to automatically deal with them at run-time. The increasing demand for complex networked software, which makes computing resources available to anyone, anywhere and at any time, is drawing attention to the engineering of self-adaptive software. The objective of our work is to define a process and a tool-supported design framework to develop self-adaptive systems, which consider Belief-Desire-Intention agent models as reference architectures. We adopt an agent-oriented approach, which allows to explicitly model system goals in requirements specification and in the system architecture design. Moreover, goal achievement conditions are specified along with their relationships with the environment and with possible failures, and corresponding recovery actions. This paper aims at motivating and giving an overview of our approach with the help of an example.

High variability design for software agents: Extending Tropos

Many classes of distributed applications, including e-business, e-government, and ambient intelligence, consist of networking infrastructures, where the nodes (peers)—be they software components, human actors or organizational units—cooperate with each other to achieve shared goals. The multi-agent system metaphor fits very well such settings because it is founded on intentional and social concepts and mechanisms. Not surprisingly, many agent-oriented software development methods have been proposed, including GAIA, PASSI, and Tropos. This paper extends the Tropos methodology, enhancing its ability to support high variability design through the explicit modelling of alternatives, it adopts an extended notion of agent capability and proposes a refined Tropos design process. The paper also presents an implemented software development environment for Tropos, founded on the Model-Driven Architecture (MDA) framework and standards. The extended Tropos development process is illustrated through a case study involving an e-commerce application.

From stakeholder intentions to software agent implementations

Multi-Agent Systems have been proposed as a suitable conceptual and technological framework for building information systems which operate in open, evolving, heterogeneous environments. Our research aims at proposing design techniques and support tools for developing such complex systems. In this paper we address the problem of better linking requirements analysis to detailed design and implementation in the Tropos agent-oriented methodology with the aim to address adaptability issues. In particular, we revisit the definition of agent capability in Tropos and refine the development process in order to point out how capability specification can result from the integration of various analysis strategies. We also show how fragments of an implementation can be generated automatically from an agent capability specification.

A Goal-Oriented Approach for Modelling Self-organising MAS

Autonomous software agents provide a promising solution to the needs of decentralised networked systems, able to adapt their behaviour in a complex and dynamically changing environment. Current agent-oriented software engineering methodologies tend to focus on different levels to realise such a self-adapting behaviour, namely the agent individual level and the global system level. The first requires to design a goal-directed agent behaviour, the second to design agents able to optimize their coordination with other peer agents in the organization, giving rise to system-level adaptation. In this paper we propose to extend a goal-oriented engineering methodology to deal with the modelling of organisations that are able to self-organise in order to reach their goals in a changing environment. To deliver on this aim, we combine Tropos4AS , an extension of TROPOS for adaptive systems, with concepts, guidelines and modelling steps from the ADELFE methodology, which provides a bottom-up approach for engineering collaborative multi-agent societies with an emergent behaviour. The resulting MAS has self-adaptation properties, having agents that are able to change their behaviour according to changes in the environment, and having organisations that adapt themselves to changing needs. The approach is illustrated by modelling a collaborative multi-agent system for conference management.

Modelling Self-Adaptivity: A Goal-Oriented Approach

Self-adaptive systems aim at autonomously achieving their objectives in a dynamic environment, adapting their behavior to different circumstances. We claim that appropriate software engineering methodologies are needed to define and to model the information necessary for a system to perform autonomous diagnosis and decision making at runtime.In this short paper we focus on conceptual modeling for the design of self-adaptive software. Our design framework adopts a goal-oriented approach to specify variability in system requirements, coping with some limits of current goal modeling approaches.

From Capability Specifications to Code for Multi-Agent Software

Current ICT application domains, such as Web services and autonomic computing, call for highly flexible systems, capable of adapting to changing operational environments as well as to user needs. Multi-agent system framework do include mechanisms that make flexibility and adaptability possible. In our research we focus on how to take into account environmental constraints and stakeholder needs in the design of software agent capabilities

Engineering requirements for adaptive systems

Abstract The increasing demand for complex and distributed software calls for novel software engineering methods and techniques, to create systems able to autonomously adapt to dynamically changing situations. In this paper, we present a framework for engineering requirements for adaptive software systems. The approach, called Tropos4AS, combines goal-oriented concepts and high-variability design methods. The Tropos4AS requirements model can be directly mapped to software prototypes with an agent-oriented architecture which can be executed for requirements validation and refinement. We give a comprehensive description of the framework, with conceptual models, modelling guidelines, and supporting tools. The applicability of the framework to requirements validation and refinement is illustrated through a case study. Two controlled experiments with subjects provide an empirical evaluation of the proposed modelling language, with statistical evidence of the effectiveness of the modelling approach for gathering requirements of adaptive systems.

Automated Mapping from Goal Models to Self-Adaptive Systems

Self-adaptive systems should autonomously adapt at run time to changes in their operational environment, guided by the goals assigned by their stakeholders. We present a tool that supports goal-oriented modelling and generation of code for goal-directed, self-adaptive systems, supporting Tropos4AS, an extension of the software engineering methodology Tropos.

Cooperation Strategies for Information Integration

We discuss and analyse cooperation strategies for rewriting queries in a mediator architecture. According to this approach, the mediated schema of each mediator is dynamically updated through the cooperation with information sources and other mediators, strongly influenced by the queries submitted by a consumer. This approach allows a mediator to face systems where information sources and consumer needs are dynamic. From the analysis of different cooperation strategies arises that it is more efficient and effective to directly cooperate with information sources when the sources are few. Otherwise, it is more efficient to cooperate with other mediators.

A design framework for generating BDI-agents from goal models

We define a tool-supported design framework that allows to specify an agent goal model and to automatically generate fragments of a BDI agent from it. We devise the design process as a transformation process from platform-independent design models to platform-specific models and then to code. The design framework is demonstrated by referring to the Tropos methodology and to the JADE/Jadex platform. In this short paper, key steps in the process are illustrated through an example.