nach oben

2008 | Buch

Kapitel lesen Erstes Kapitel lesen

Agent-Oriented Software Engineering VIII

8th International Workshop, AOSE 2007, Honolulu, HI, USA, May 14, 2007, Revised Selected Papers

herausgegeben von: Michael Luck, Lin Padgham

Verlag: Springer Berlin Heidelberg

Buchreihe : Lecture Notes in Computer Science

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten

Über dieses Buch

Software architectures that contain many dynamically interacting components, each with its own thread of control, engaging in complex coordination protocols, are difficult to correctly and efficiently engineer. Agent-oriented modelling techniques are important for the design and development of such applications. This book provides a diverse and interesting overview of the work that is currently being undertaken by a growing number of researchers in the area of Agent-Oriented Software Engineering.

This volume constitutes the thoroughly refereed proceedings of the 8th International Workshop on Agent-Oriented Software Engineering, AOSE 2007, held in Honolulu, Hawaii in May 2007 as part of AAMAS 2007. The 16 revised full papers were carefully selected from numerous submissions during two rounds of reviewing and improvement. The volume contains the papers presented at the workshop, together with papers resulting from discussions on tools and platforms. The papers have been organized into four sections on: methodology and processes, interacting heterogeneous agents, system development issues, and tools and case studies.

Inhaltsverzeichnis

Frontmatter

AOSE Methodology and Processes

O-MaSE: A Customizable Approach to Developing Multiagent Development Processes

Abstract

This paper describes the Organization-based Multiagent System Engineering (O-MaSE) Process Framework, which helps process engineers define custom multiagent systems development processes. O-MaSE builds off the MaSE methodology and is adapted from the OPEN Process Framework (OPF). OPF implements a Method Engineering approach to process construction. The goal of O-MaSE is to allow designers to create customized agent-oriented software development processes. O-MaSE consists of three basic structures: (1) a metamodel, (2) a set of methods fragments, and (3) a set of guidelines. The O-MaSE metamodel defines the key concepts needed to design and implement multiagent systems. The method fragments are operations or tasks that are executed to produce a set of work products, which may include models, documents, or code. The guidelines define how the method fragments are related to one another. The paper also shows two O-MaSE process examples.

Juan C. Garcia-Ojeda, Scott A. DeLoach, Robby, Walamitien H. Oyenan, Jorge Valenzuela

Extending Gaia with Agent Design and Iterative Development

Abstract

Agent-oriented methodologies are an important means for constructing agent-based systems in a controlled repeatable form. However, agent-oriented methodologies have not received much acceptance in industrial environments, which can be partially explained by drawbacks in current agent-oriented methodologies, mainly in terms of applicability and comprehensiveness. Specifically, Gaia, one of the most cited methodologies, does not consider agent design, nor exhibits an agile methodological process. On the other hand, Gaia is based on organisational abstractions (which makes it suitable to cope with the design of complex systems) and possesses a simple methodological process whose neutrality makes it suitable for extensions. In this paper, we extend Gaia in two directions: we incorporate an agent design phase, and we enhance the methodological process with the use of iterations.

Jorge Gonzalez-Palacios, Michael Luck

AgentPrIMe: Adapting MAS Designs to Build Confidence

Abstract

The products of systems cannot always be judged at face value: the process by which they were obtained is also important. For instance, the rigour of a scientific experiment, the ethics with which an item was manufactured and the use of services with particular licensing all affect how the results of those processes are valued. However, in systems of autonomous agents, and particularly those with multiple independent contributory organisations, the ability of agents to choose how their goals or responsibilities are achieved can hide such process qualities from users. The issue of ensuring that users are able to check these process qualities is a software engineering one: the developer must decide to ensure that adequate data is recorded regarding processes and safeguards implemented to ensure accuracy. In this paper, we describe AgentPrIMe, an adjunct to existing agent-oriented methodologies that allows system designs to be adapted to give users confidence in the results they produce. It does this by adaptations to the design for documentation, corroboration, independent storage and accountability.

Simon Miles, Paul Groth, Steve Munroe, Michael Luck, Luc Moreau

Refining Goal Models by Evaluating System Behaviour

Abstract

Nowadays, information systems have to perform in complex, heterogeneous environments, considering a variety of system users with different needs and preferences. Software engineering methodologies need to cope with the complexity of requirements specification in such scenarios, where new requirements may emerge also at run-time and the system’s goals are expected to evolve to meet new stakeholder needs.

Following an agent-oriented approach, we are studying methods and techniques to design adaptive and evolvable information systems able to fulfill stakeholders’ objectives.

In a previous work we defined an Agent-Oriented framework to design and code system specifications in terms of goal models and we instantiated it in a tool supported process which exploits the Agent-Oriented Software Engineering methodology Tropos and the Multi-Agent Platform JADE/Jadex [11].

In this paper, we show how to use this framework to develop a system following an iterative process, where the system execution allows enriching the system specification given in terms of goal models.

Experimental evaluation has been performed on a simple example and lead to the refinement of the designed goal model upon the analysis of the system’s run-time behaviour.

Mirko Morandini, Loris Penserini, Anna Perini, Angelo Susi

A Goal-Oriented Software Testing Methodology

Abstract

Agent-Oriented Software Engineering (AOSE) methodologies are proposed to develop complex distributed systems based upon the agent paradigm. The natural implementation for such systems has usually the form of Multi-Agent Systems (MAS). As these systems are increasingly applied in mission-critical services, assurances need to be given to their owners and users that they operate properly. Although the relevance of the link between requirements engineering and testing has long been recognized, current Agent-Oriented Software Engineering methodologies partially address it. Some of them offer specification-based formal verification, allowing software developers to correct errors at the beginning of the development process, others exploits Object-Oriented (OO) testing techniques, upon a mapping of agent-oriented abstractions into OO constructs. However, a structured testing process for AOSE methodologies that complements formal verification is still missing.

In this paper we introduce a testing framework for the AOSE methodology Tropos. It specifies a testing process model that complements the agent-oriented requirements and design models and strengthens the mutual relationship between goal analysis and testing. Furthermore, it provides a systematic way of deriving test cases from goal analysis. We call this approach goal-oriented testing.

Duy Cu Nguyen, Anna Perini, Paolo Tonella

Interacting Heterogeneous Agents

Open Agent Systems ???

Abstract

E-institutions are envisioned as facilities on the Internet for heterogeneous software agents to perform their interactions and thus forming truly open agent systems. We investigate how these heterogeneous agents can determine whether an institution is one in which they can participate. We propose a layered approach which is supported through a (traditional) middle agent that is part of the environment. Starting with a basic compatibility of message types, each extra layer ensures a higher degree of compatibility, but requires also extra sophistication in both the information required and the matching algorithms. In this paper, we describe reasoning about how an agent should take on a specific role, message matching, and protocol compatibility. We explore the issues in the context of an actual accommodation agent built in JACK, and a travel agency institution built in ISLANDER.

Frank Dignum, Virginia Dignum, John Thangarajah, Lin Padgham, Michael Winikoff

An Agent Framework for Processing FIPA-ACL Messages Based on Interaction Models

Abstract

Interaction engineering is a key issue to effectively build Multi-Agent Systems. It requires software abstractions, components and control structures to manage interactions among agents and to improve infrastructures at runtime. We propose a framework for automatic processing of interactions generated using FIPA-ACL, a language widely accepted for agent platforms. This framework includes three elements: i) an agent interaction architecture to systematize interaction processing tasks, ii) interaction models to build re-usable validated code used to check different phases of interaction processing associated with message semantics, and iii) components and control structures implementing interaction architecture for a particular agent platform. The paper describes the implementation details of the proposed approach developed within the CAPNET agent platform and illustrates it by example.

Ernesto German, Leonid Sheremetov

A Methodology for Developing Multiagent Systems as 3D Electronic Institutions

Abstract

In this paper we propose viewing Virtual Worlds as open Multiagent Systems and propose the 3D Electronic Institutions methodology for their development. 3D Electronic Institutions are Virtual Worlds with normative regulation of interactions. More precisely, the methodology we propose here helps in separating the development of Virtual Worlds based on the concept of 3D Electronic Institutions into two independent phases: specification of the institutional rules and design of the 3D interaction environment. The new methodology is supplied with a set of graphical tools that support the development process on every level, from specification to deployment. The resulting system facilitates the direct integration of humans into Multi-Agent Systems as they participate by driving an avatar in the generated 3D environment and interacting with other humans or software agents, while the institution ensures the validity of their interactions.

Anton Bogdanovych, Marc Esteva, Simeon Simoff, Carles Sierra, Helmut Berger

System Development Issues

Reasoning About Risk in Agent’s Deliberation Process: A Jadex Implementation

Abstract

Autonomous agents and multi-agent systems have been proved to be useful in several safety-critical applications. However, in current agent architectures (particularly BDI architectures) the deliberation process does not include any form of risk analysis. In this paper, we propose guidelines to implement Tropos Goal-Risk reasoning. Our proposal aims at introducing risk reasoning in the deliberation process of a BDI agent so that the overall set of possible plans is evaluated with respect to risk. When the level of risk results too high, agents can consider and introduce additional plans, called treatments, that produce an overall reduction of the risk. Side effects of treatments are also considered as part of the model. To make the discussion more concrete, we illustrate the proposal with a case study on the Unmanned Aerial Vehicle agent.

Yudistira Asnar, Paolo Giorgini, Nicola Zannone

Generation of Repair Plans for Change Propagation

Abstract

One of the most critical problems in software maintenance and evolution is propagating changes. Although many approaches have been proposed, automated change propagation is still a significant technical challenge in software engineering. In this paper we present an agent-oriented change propagation framework based on fixing inconsistencies when primary changes are made to design models. A core piece of the framework is a new method for generating repair plans from OCL constraints that restrict these models.

Khanh Hoa Dam, Michael Winikoff

An Expressway from Agent-Oriented Models to Prototypes

Abstract

Agent-oriented software engineering can be viewed as applying software engineering principles to agent-oriented development or applying agent-oriented principles to software engineering. In this paper, we are more concerned with the second view. We describe how prototype systems can be efficiently created from agent-oriented domain and design models. We propose a conceptual space that accommodates model transformations described by the Model-Driven Architecture. We explain agent-oriented domain models and platform-independent design models and show how the first can be mapped to the latter. We demonstrate how design models can be turned into the implementation of an agent-based prototype on a specific platform. The approach has potential for accelerating the process of rapid prototyping.

Kuldar Taveter, Leon Sterling

Tools and Case Studies

Introduction to AOSE Tools for the Conference Management System

Abstract

Over several years, conference management systems have been used as an example to illustrate various aspects of computing, in particular agent-oriented software engineering methodologies. At AOSE in 2007, the conference management system was used as a basis for providing a comparison of different AOSE tools and methodologies from different researchers. This paper provides an overview of the basic system, and an introduction to the papers describing those methodologies and tools that follow.

Lin Padgham, Michael Luck

Developing a Multiagent Conference Management System Using the O-MaSE Process Framework

Abstract

This paper describes how the Organization-based Multiagent Systems Engineering (O-MaSE) methodology can be applied to an exemplar multiagent system, the Conference Management System. First, a custom process for the CMS application is created using the O-MaSE Process Framework. Then, each task identified in the O-MaSE compliant process is performed and the appropriate models are generated. For the CMS system, we begin by creating a Goal Model via the Model Goals and Goal Refinement tasks. Once the Goal Model is complete, we create an Organization Model to capture all the interfaces to external actors and systems. After that, a Role Model is created to capture the functionality and the logical architecture of the system. Next, based on the Role Model, an Agent Class Model is created. The details of the agents and protocols identified in the Agent Class Model are further refined into several Protocol Models and Agent Plan Models.

Scott A. DeLoach

Tool-Supported Development with Tropos: The Conference Management System Case Study

Abstract

The agent-oriented software engineering methodology Tropos offers a structured development process and supporting tools for developing complex, distributed systems.

The objective of this paper is twofold: first, to illustrate the use of Tropos to develop a Multi-Agent System, performing basic analysis and design activities, code generation and testing, with the support of a set of tools; second, to enable the comparison with other, tool-supported, agent-oriented software engineering methodologies through a description of the main steps of these activities and of excerpts of the resulting artefacts, with reference to a common case study, namely, the Conference Management System case study.

Mirko Morandini, Duy Cu Nguyen, Anna Perini, Alberto Siena, Angelo Susi

The Prometheus Design Tool – A Conference Management System Case Study

Abstract

This paper describes how the Prometheus Design Tool (PDT) is used to support the Prometheus methodology for designing agent systems. This is done by using an exemplar system that has been used previously in the literature, and is briefly described earlier in this volume. This paper presents the development of a design for this system using PDT. By using different tools and methodologies to design the same example system it is easier to observe the similarities and differences between both the methodologies and the tools supporting them. Prometheus and PDT, like the other systems presented in this volume, has specific strengths and features that have been developed to support the design process. However it is also evident that there is a great deal of commonality across agent methodologies that should give developers confidence that there is in fact an emerging agreed understanding as to the important aspects of designing and developing agent systems.

Lin Padgham, John Thangarajah, Michael Winikoff

Developing a Conference Management System with the Multi-Agent Systems Unified Process: A Case Study

Abstract

Many methodologies appeared in the latest years to deal with multi-agent systems complexity and special development requirements. Each methodology focuses in certain aspects of multi-agent systems development and use different case studies to prove their effectiveness. In order to compare their characteristics it is necessary to use a single case study that requires a complex and distributed solution. This paper presents the development of a very well-known multi-agent systems case study – the Conference Management System – with the Multi-agent Systems Unified Process (MASUP).

Danilo Santos, Marcelo Blois Ribeiro, Ricardo Bastos

Backmatter

Titel: Agent-Oriented Software Engineering VIII
herausgegeben von: Michael Luck
Lin Padgham
Verlag: Springer Berlin Heidelberg
Electronic ISBN: 978-3-540-79488-2
Print ISBN: 978-3-540-79487-5
DOI: https://doi.org/10.1007/978-3-540-79488-2