Table of contents

The paper discusses a methodology for establishing a closed control loop over thexecution of a plan where concurrent actions are performed by a team of agents. The initial plan is distributed among agents and each of them performs a local control loop on the progress of the sub-plan it is responsible for. As soon as an action failure is detected, the agent invokes a Local Re-Planner in order to recovery from the failure by building a new local plan. In case such a local plan does not exist, a global re-planning phase is initiated; the global re-planner receives from the agent relevant pieces of information concerning the causes of the detected failure and the actions (performed by other agents) which directly or indirectly may fail as a consequence of such a failure failure propagation). Model-Based Reasoning techniques are used for explicitly modeling the actions evolutions both in the nominal and in the abnormal situations. These extended action models play a critical role in re-planning, since the (possibly abnormal) health states of the agents can be taken into account for predicting the effects of actions.

This paper presents the promising synergy between autonomic computing systems and agent technology. More precisely, an analysis of the theoretical and pragmatic reasons that underlie this synergy is proposed. Then an agent based solution is presented to deal with autonomic computing systems. Finally, a brief survey is presented upon the studies that has been interested in fostering the link between agent technology and autonomic computing.

Electronic institutions (EIs) have been proposed as a means of regulating open agent societies. EIs define the rules of the game in agent societies by fixing what agents are permitted and forbidden to do and under what circumstances. And yet, there is the need for EIs to adapt their regulations to comply with their goals despite coping with varying populations of self-interested agents. In this paper we focus on the extension of EIs with autonomic capabilities to alllow them to yield a dynamical answer to changing circumstances through the adaptation of their norms.

Situated Autonomic software can be envisaged as a system, which acts and/or reacts autonomously to external stimuli, generated from sensing its environment, which is achieved independently of external human intervention.
This paper focuses on the theoretical development of regulatory mechanisms for deliberative autonomic software under partially observable worlds. The work details progress achieved so far, towards the design and implementation of a proposed partially observable regulation mechanism, which integrates an Extensible Believe, Desire and Intention (EBDI) model deliberation with decision theoretical approaches. Unlike other approaches, the proposed mechanism enables an autonomic system to regulate its reaction not only via logic and deontics based reasoning but also via anticipated risk or benefits (effects) of a given reaction plan.

Das Büro in der Tasche – diese Vision der Pioniere im Bereich der drahtlosen Synchronisation ist heute fester Bestandteil der modernen Arbeitswelt. Während der Datenabgleich – zwischen stationären Rechnern und mobilen Geräten – anfänglich nach proprietären Protokollen erfolgte, setzt sich zunehmend der auf XML basierenden, offenen Standard SyncML (OMA DS) durch: Kalenderdaten, Adressen und Aufgaben werden in Unternehmen aller Größen problemlos und sicher synchronisiert. Mobilfunkanbieter bringen Push E-Mail zum Endverbraucher, Firmen verwalten zentral ganze Handyflotten und Gerätehersteller vermeiden teure Rückholaktionen durch Übertragung von Firmware-Updates und Software-Patches „over the air“.

Software Systems must change to remain useful. Current programming languages and support environments however treat software systems as though they were static, unchanging and globally consistent. We argue in favour of a more dynamic approach in which complex software systems can seen as a set of overlapping and constantly changing contexts. We report on some initial research activities pointing in this direction, and we lay out our vision for taming software change.

The FAME project uses method engineering to construct a methodological approach for agent-oriented software development. Its precursor was a project utilizing the object-oriented OPEN Process Framework, in which its repository of OO-focussed method fragments was extended to support various agent-oriented methodological approaches. In this talk, I will show how method engineering provides an excellent base for constructing situation specific software engineering methodologies for both object and agent software development. Both OPF and FAME use an existing repository coupled to an appropriate metamodel (which in the near future will be the new ISO standard metamodel ISO24744, itself based on the concept of powertypes). This flexible, yet standardized repository supplies method fragments that are then configured to support specific projects. In addition, all existing, and new, OO and AO methodologies can be recreated, thus providing an industry strength resource for object-oriented and agent-oriented software development.

Globalization demands global infrastructures, e.g. for transportation, communication, and collaboration. The latter, collaboration, will be facilitated by grid infrastructures, which are currently being built in hundreds of grid projects around the world. One of them is the 5-year German D-Grid initiative which aims at developing a common grid infrastructure for "Services for Scientists", to be shared and tested by Community Grids (high-energy physics, astronomy, climate, medicine, engineering, libraries.
Recently, a 2nd Call invited new communities, IT service providers and industry users to help expand the user community, and to strengthen D-Grid towards a productive and sustainable service platform shared by scientists and industry.
This lecture will present an overview on D-Grid, and its challenges and benefits for the national and international science and industry community. In an international context, we will offer "Lessons Learned" and "Recommendations" for those who intend to build grids in the near future.

Normally current OO frameworks provided with MAS development toolkits put little emphasis on the separate (re)use of agent domain-specific unctionalities from other concerns. Component technologies promote the (re)use of COTS components as standalone entities, so modelling agent domain specific functionality as components seems to be a natural approach. However, there are other concerns that are not well separated by existing agent architectures such as the agent interaction protocols which are intermingled with the agent functionality in the same architectural component. Aspect-oriented technologies overcome this problem known as the tangled code problem modelling such crosscutting concerns as aspects. In this paper we present MaDL, a component-aspect oriented architecture description language based on XML for the configuration of software agent architectures. The joint use of component and aspect technologies improves agent internal architecture, which is therefore more adaptable to new functional requirements and promotes reuse.

Several agent researchers are currently studying agent modeling and they propose different architectural metamodels for developing Multiagent Systems (MAS) according to specific agent development methodologies. When support for Semantic Web technology and its related constructs are considered, agent metamodels should include meta-entities to model MASs which work in semantic web environment. In this paper, we introduce an agent metamodel to define the required constructs of a Semantic Web enabled MAS in order to provide semantic capability modeling and interaction of agents both with other agents and semantic web services. We give a conceptual MAS architecture to identify new constructs in addition to constructs of a traditional MAS and propose a metamodel including the first-class entities required by such a conceptual architecture.

To accommodate the rapidly evolving business envi-ronments, there is a need for workflow management systems that can activate intra organizational business processes, in an efficient way. In this paper an Agent-Based Workflow Management System (AB-WfMS) is presented with the aim of supporting this issue through the adoption of agent technology. The proposed enterprise architecture has set apart some of the classical management responsibilities of central workflow engine, for autonomous process agents. In this way, the paper proposes a scalable workflow management system, which is applicable for a wide range of distributed heterogeneous business management environments.

Time emerges as a key concept in Multi Agent Systems (MASs) and influences the overall system architecture. Since architectural abstractions aim at capturing issues that are relevant in specific domains, MAS architectures should provide abstractions allowing the temporal behaviour to be modelled, observed, and controlled. In other terms, time should be a full-fledged first-class concept in MAS architectures. This paper proposes Time-Awareness Model (TAM), a reference model for building Time-Aware MASs. The model defines a collection of architectural abstractions allowing temporal issues to be modelled in a platform-independent way. Moreover, the paper applies TAM in a reference architecture for Time-Aware MASs. The reference architecture has been exploited in the Packet-World test-bed.

Prosa is a reference architecture for manufacturing control. This paper is inspired by the practical experience of our group in applying this reference architecture in concrete applications. The paper makes two key observations . As a first observation, all entities in the 'world of interest' should not only be represented as an agent in the multi-agent system but also as an entity in the environment. A second observation is that there exist multiple viewpoints on the basic elements in the reference architecture. Two examples of such viewpoints are given. The paper explains how PROSA merges both views.

Envisions of future network enabled socio-technical systems are in focus of several international ongoing efforts by industry and academia. Different interest groups, e.g., the agent and the Grid computing communities, have to that end put forward several roadmaps. However, those roadmaps by and large presuppose a key role to be played by their favorite technologies. We propose another complementary approach with a focus on the requirements on the goal system (Network Enabled Capabilities) and a generic configurable framework to support design, implementation, monitoring, and maintenance of future dependable and secure socio-technical systems. Our methodological approach is grounded on IEEE standards on software intensive systems and on own experiences of development of such systems. We propose the use of agent technologies foremost in requirement engineering and high-level design whence the implementation platform is in our cases preferably based on Service Oriented Architectures as in Grid computing.

Infinite recursion is a known problem of aspect-oriented programming with AspectJ: if no special precautions are taken, aspects which advise other aspects easily and unintentionally advise themselves. We present a compiler for an extension of the AspectJ programming language that avoids self reference by associating aspects with levels, and by automatically restricting the scope of pointcuts used by an aspect to join points of lower levels. We report on a case using our language extension and quantify the changes necessary for migrating existing applications to it. Our results suggest that we can make programming with AspectJ simpler and safer, without restricting its expressive power unduly.

Current Web Services integration approaches fail at supporting a highly flexible service selection and management. To overcome these problems, the Web Services Management Layer was proposed in previous work. However, this layer presents some limitations due to the implicit representation of service criteria that guide its customization. In this paper we propose externalizing these criteria as high-level business rules. Moreover, the specification of new unanticipated business rules is also supported. We do this by employing a high-level business rule language proposed in previous work. We show how this rule language can be used to customize the WSML, enhancing flexibility. The originality of our approach is the application of a general-purpose business rule language to the domain of Web Services management.

Topics
-Aspect-oriented concepts, languages and technologies
-Dynamic software adaptation
-Service-Oriented Architectures & Computing

In aspect-oriented programming, aspects require access to join point information for selecting join points within pointcuts as well as for specifying aspect-specific behavior at such join points within advice. Unfortunately, aspect-oriented systems typically provide only local information about join points, i.e. information that is directly accessible from the execution context that available at join points. However, there are many situations where the needed information is not directly available and relies on object information that is non-local concerning the execution context of the corresponding join points. As a consequence, developers are forced to specify a number of work-arounds – pointcuts and advices that neither reflect on the conceptual join point selection nor purely on the conceptual aspect behavior. In this paper, we show recurring situations in which “local” join point information is not sufficient for specifying aspects. We propose so called “path expression pointcuts” that permit to abstract over (non-local) objectrelationships within pointcuts – and show that this overcomes the problem.

In both development and maintenance of software, finding and fixing bugs take a huge percentage of the overall time and resources. Traditional debugging and stepping execution trace are well-accepted techniques to understand deep internals about a program. However in many cases navigating the stack trace is not enough to find bugs, since the cause of a bug is often not in the stack trace anymore and old state is lost, so out of reach from the debugger. Therefore there is a challenge in providing new ways of debugging.
In this paper, we present the design and implementation of a backward-in-time debugger for a dynamic language, i.e., a debugger that allows one to navigate back the history of the application. We present the design and implementation of a backward-in-time debugger called Unstuck and show our solution to key implementation challenges.

Topics
-Object-oriented concepts, languages and technologies
-Software architecture, maintenance, and evolution

Feature modeling is an important approach to dealing with variability at an abstract level in a hierarchical manner extensively used in software product lines. For its use in conjunction with other UML models and MDA approach, it is important to correctly integrate feature modeling into UML. In this paper, we present an approach to integrating feature modeling into UML that respects abstractness of feature modeling elements. This is achieved by deriving feature modeling elements from the deeper levels of the UML metamodel. We applied this approach to the essential elements of feature modeling in the cardinality-based Czarnecki-Eisenecker notation and selected elements specific to other notations.
Since UML modeling tools do not support such modifications of the UML metatmodel, in order to facilitate experimentation with combining elements from different notations, we implemented this feature modeling extension as a UML profile (in Enterprise Architect and Omondo UML).

Topics
-Software architecture, maintenance, and evolution
-Generative programming

Aspect-oriented software development still lacks practical evidence. While aspects are claimed to be useful in adapting existing applications there is also first evidence that they might themselves be re-usable. We present results from two case studies with the aspect-oriented programming language ObjectTeams/Java that investigate the re-usability of aspects in developing a security framework. During the development of the framework we have identified patterns for re-usable aspects that increase the flexibility when applying a framework to a given application.