Catálogo de publicaciones - libros

Object-oriented methodologies are well-established and have been used as one input for the creation of methodologies suitable to support the development of agent-oriented software systems. While these agent-oriented (AO) methodologies vary in style and, particularly, in heritage and often with a specific focus (either in terms of domain, application style or lifecycle coverage), for industry adoption it is essential that full lifecycle coverage is achieved in a “standardized” way. One way of achieving some degree of standardization yet maintaining full flexibility is through the use of situational method engineering (SME). With this approach, method fragments are created and stored in a repository. For an individual software development, a subset of these is then selected from the repository and a project-specific (or sometimes organization-specific) methodology is constructed. Here, we demonstrate how this might work by using the OPEN approach that already provides a significant coverage of AO method fragments as well as more traditional OO and pre-OO fragments. Those newer fragments supporting AO approaches are detailed, describing, as they do, emerging substantial support for AO methodological creation from the OPEN repository in an SME context.

Multi-agent systems modeling is a very demanding task especially because the software development processes currently being used are based on different paradigms. This work proposes a process to specify agent-oriented information systems that extends RUP. The models are specified through successive refinements using use cases as the reference to express the system requirements. The design model takes into account the infrastructure services required to implement the solution using a multi-agent approach. The models are represented basically by extended UML and AUML diagrams and notations.

The need of developing a new software engineering process to allow the quick prototyping of some robotic applications and meet the requests by some companies for a development process that was shorter than PASSI, gave us the opportunity of applying our studies on the assembling of a new SEP by reusing parts (called method fragments) from other processes. In this paper we discuss our approach that, starting from the method engineering paradigm, adapts and extends it considering specific agent-oriented issues like the multi-agent system meta-model. The final result of our experiment (Agile PASSI) is presented together with the requirements that motivated its structure.

The development of Multi-Agent Systems (MASs) involves special concerns, such as interaction, adaptation, autonomy, among others. Many of these concerns are overlapping, crosscut each other and the agent’s basic functionality. Over the last few years, several methodologies and implementation frameworks have been proposed to support agent-oriented software engineering. Although these approaches have brought some benefits to improve the productivity and quality on the MAS development, they present some restrictions. First, agent-oriented methodologies are too high level and do not indicate how to master the complexity of MAS concerns based on the object-oriented abstractions. Second, implementation frameworks provide object-oriented APIs for MAS development without providing guidelines for the modularization of agent concerns. Moreover, neither of the proposed agent oriented-approaches deals with the modeling and implementation of agent crosscutting concerns. This paper presents a generative approach for the development of MASs that addresses these restrictions. The proposed approach explores the MAS domain to enable the code generation of heterogeneous agent architectures. Aspect-oriented techniques are used to allow the modeling of crosscutting agent features. The generative approach brings several benefits to the code generation and modeling of agent crosscutting features since early development stages.

In the last few years, software applications have increased in complexity and in stakeholder’s expectations principally due to new Internet-centric application areas such as e-business, web services, ubiquitous computing, and peer-to-peer networks. Multi-agent systems (MAS) architectures have gained popularity for developing such software. Unfortunately, despite considerable work in software architecture during the last decade, few research efforts have aimed at truly defining frameworks for agent-based architectural design. Considering that a MAS architecture is conceived as a society of software agents, this paper overviews SKwyRL, a social-driven design framework dedicated to build up agent-based systems. The framework proposes a modern approach based on organizational structures and social patterns to define agent architectures notably in the context of e-business system design.

Software systems of today are characterized by increasing size, complexity, distribution and heterogeneity. Understanding and supporting the interaction between software requirements and architectures remains one of the challenging problems in software engineering research. The terminology and concepts used for architectural description are quite different from those used for the requirement specification. In spite of this, there is a clear relationship between requirements and architectures. In this chapter we present an approach for integration of system requirements and software architectures within the context of the Tropos project, an information system development framework that is requirement-driven in the sense that it adopts concepts used during early requirements analysis. Our framework advocates that a software system corresponds to the organizational structure, in which actors are members of a group in order to perform specific tasks.

Engineering non-trivial open multi-agent systems is a challenging task. Our research focusses on situated multi-agent systems, i.e. systems in which agents are explicitly placed in a context – an environment – which agents can perceive and in which they can act. Two concerns are essential in developing such open systems. First, the agents must be adaptive in order to exhibit suitable behavior in changing circumstances of the system: new agents may join the system, others may leave, the environment may change, e.g. its topology or its characteristics such as throughput and visibility. A well-known family of agent architectures for adaptive behavior are free-flow architectures. However, building a free-flow architecture based on an analysis of the problem domain is a quasi-impossible job for non-trivial agents. Second, multi-agent systems developers as software engineers require suitable abstractions for describing and structuring agent behavior. The abstraction of a role obviously is essential in this respect. Earlier, we proposed statecharts as a formalism to describe roles. Although this allows application developers to describe roles comfortably, the formalism supports rigid behavior only, and hampers adaptive behavior in changing environments.

In this paper we describe how a synergy can be reached between free-flow architectures and statechart models in order to combine the best of both worlds: adaptivity and suitable abstractions. We illustrate the result through a case study on controlling a collection of automated guided vehicles (AGVs), which is the subject of an industrial project.

Agent architectures have to cope with a number of internal properties (concerns), such as autonomy, learning, and mobility. As the agent complexity increases, these agent properties crosscut each other and the agent’s basic functionality. In addition, multi-agent systems encompass multiple agent types with heterogeneous architectures. Each of these agent types has different properties, which need to be composed in different ways. In this context, the separation and the flexible composition of agent concerns are crucial for the construction of heterogeneous agent architectures. Moreover the separation of agent concerns needs to be guaranteed throughout the different development phases, especially from the architectural to the implementation phase. Existing approaches do not provide appropriate support for the modularization of agent properties at the architectural stage, and do not promote a smooth transition to the system implementation. This paper presents an aspect-oriented method that allows for a better separation of concerns, supporting the systematic of agent properties through the architectural definition, detailed design and implementation. A multi-agent system for paper reviewing management is assumed as a case study through this paper to show the applicability of our proposal.

This paper presents an agent-oriented modelling language and environment CAMLE. It is based on the conceptual model of multi-agent systems (MAS) proposed and formally defined in the formal specification language SLABS. It is caste-centric because the notion of caste plays the central role in its methodology. Caste is the classifier of agents in our language. It allows multiple and dynamic classifications of agents. It serves as the template of agents and can be used to model a wide variety of MAS concepts, such as roles, agent societies, etc. The language supports modelling MAS at both macro-level for the global properties and behaviours of the system and micro-level for properties and behaviours of the agents. The environment provides tools for constructing graphic MAS models in CAMLE, automatically checking consistency between various views and models at different levels of abstraction, and automatically transforming models into formal specifications in SLABS. The uses of the CAMLE modelling language and environment are illustrated by an example.

Multiagent systems are characterized by decentralized control and agents that perform autonomous actions. The sequence of such actions are generally described by plans. An important issue in this context is how to verify the correctness of plans when agents have unpredicted actions. In this paper, formal modelling and verification guidelines to verify nondeterministic multiagent system plans are introduced. The guidelines are based on HCPN modelling, simulation, and model checking. The guidelines are conceptually introduced, and then applied for a multiagent intelligent tutoring system modelling and verification.