Verzeichnis der Vorträge

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.

Next generation middleware must support applications in the face of increasing diversity in interaction paradigms, end system types and network styles.
Therefore, to secure applications, flexible security policies must be configured and indeed reconfigured at runtime. In this paper, we propose an approach combining the openness of reflective middleware with the flexibility of programmable security to meet such demands. In particular, we build a security architecture based on the Gridkit reflective middleware platform and the Obol security protocol programming language. The paper then describes a case study that uses flexible policies in order to secure remote procedure calls and secure group communication. We also evaluate this approach in terms of its security properties, flexibility, ease of use and extensibility.

-Metaprogramming and reflection
-Dynamic software adaptation
-Self-Adaptive Architectures & Systems

Open source software systems provide a variety of field-tested components offering software development organizations the potential to reuse and adapt such components for their own purposes. The main challenge before achieving the reuse benefits is to acquire a thorough understanding of open source software systems (i.e., the reuse candidates) in order to reason about alternative solutions,to learn about the points where to adapt the system and eventually to decide?whether or not to invest into reuse. Manually analyzing even small systems is a time-consuming, complex and costly task. In this paper we demonstrate how a software architecture visualization and evaluation tool supported and facilitated our comprehension tasks to learn about the architectural means and concepts implemented in the Apache Tomcat web server.

Topics
-Software architecture, maintenance, and evolution

System solutions are moving towards ubiquitous and distributed technologies using policies, profiles etc. as this potentially enables higher level semantic interoperability through making representations formal and explicit. However, it also creates more opportunity for semantic-based attacks.

The development and advancement of autonomic computing could provide mechanisms to solve some of the challenges of capturing privacy preferences and managing these preferences in peer-to-peer environments and assisting in avoiding some of the potential challenges with semantic-based attacks. In particular dealing with privacy preferences when sharing multimedia content.

We are dealing with the support of privacy preferences within a particular application domain, which is in the sharing of content. The content is a collection of metadata, images, videos, personal annotations etc. and is captured as a collection as an autonomous content entity. This is within the context of an EU project called aceMedia. This paper addresses dealing with privacy preferences within the context of P2P environments, where a concept of autonomy exists when sharing content with other users or systems. The rules are generated on the fly to deal with the context required at the given time as it is impossible to define before hand all the types of user preferences to be applied to their content. These rules are self-governing of the autonomous content itself, thus are part of the content. The design of the self-governance mechanism used is provided.

From the biology's point of view, pollination is an important step in the reproduction of seed plants. From the software engineer's view, pollination may evolve to a promising, biologically inspired paradigm for future, self-managing computing systems. This estimation is based on the self-* properties implied inherently by the pollination process between plants and insects. To exploit these characteristics for artificial, self-managing systems, this paper analyzes the components and sub-processes involved in the natural pollination process and identifies the emerging self-* properties. Based on that, the paper adapts this process by a formal specification for artificial pollination systems as well as a meta model of their system architecture. The paper illustrates the adaption's benefits by a case study and evaluates its capabilities and limitations. Finally, it presents open issues and an outlook on future work.

Methods from formal specification and verification have been successfully applied to the description of complex and reactive systems. In our research we observed however that these methods lead to monolithic models which describe important aspects of behavior but do not provide the flexibility and adaptivity which is necessary to cope with reactive behavior and environmental conditions. These adaptive properties are naturally provided by metaheuristics which simulate the capabilities of natural processes (e.g. ant colony algorithms). In our approach we propose a hybrid framework which combines the power of automatic reasoning with ant colony algorithms in order to combine the positive aspects from both research areas. In this paper we demonstrate how to combine robust and inexpensive verification algorithms with the adaptivity of virtual ant colonies. We consider this feature to be a contribution to context awareness of complex systems and to autonomic computing.
Keywords:
Ant Colony Optimization
Tuple Tree Automata
Fuzzy Description Logics
High-Level Specification
Context-Awareness.

Motion information is important to describe video. In order to pre-classify video well, we need to find a good classifier to distinguish P frames of global and local motions. In this paper, according to coding characteristics of MPEG, a novel algorithm called MPCA-MSOM is used as the classifier, which is a combination of multi-layer self-organizing map (SOM) and principal component analysis (PCA). In the MPCA-MSOM algorithm, we subdivide the imprecise clustering in the traditional SOM algorithm layer by layer. In addition, PCA is used to select features. Experimental results show that the MPCA-MSOM algorithm increases recognition ratio, and works better than the other methods.

Fuzzy Logic is, nowadays, a control technique widely extended in nonlinear system applications. This work adds a new point-of-view to the continuous efforts in search of an optimized hardware-software co-design of a dual-input single-output fuzzy logic controller (FLC). Our approach breaks up with the defuzzification cores– to focus it on directly synthesizing the resultant control surface. An innovative design methodology is defined by firstly splitting the total area in rectangular sectors to, afterwards, model each of them by second-order polynomial functions. The algorithm is finally embedded in a MCU-FPGA platform to achieve a balanced cost-performance solution inspired by such efficient concepts in terms of run-time and silicon-area as parallel processing and dynamic partial reconfiguration, respectively. The result is a universal FLC where the control surface is parameterized and handled through a simple data file appended to the design bitstream in the way of initialized SRAM memory. This HW/SW architecture therefore provides a general-purpose solution able to customize whichever fuzzy application by only updating the data that model the particular control surface segmented in rectangular sectors.

This paper targets the reactive autonomic system?s self-monitoring of one of the most important non-functional properties, reliability. There are currently no adequate frameworks for tackling reliability in reactive and autonomic systems with self-monitoring functionality. The proposed in the paper reliability self-assessment of the Autonomic System Timed Reactive Model (AS-TRM) is based on the theory of Markov chains and is concerned with the uncertainty analysis of the AS-TRM as it evolves. An appro-priate architecture for supporting reliability self-assessment is presented, along with a communica-tion mechanism to implement the reactive and autonomic behavior. The reliability assessment is illustrated on a case study.

Coordination of mechatronic systems will raise the level of utility of such products. To realise the maximum gain of utility, it is not enough to coordinate just the current actions of the mechatronic systems. Only a forward looking coordination can alter future actions of mechatronic systems in order to realise synergy effects. We assume that mechatronic systems act autonomous and maybe act selfish, for instance due to their owner. For this reason the application of centralised systems is not suitable. This idea leads directly to multiagent planning. In this paper we introduce our first steps on a way to a cooperative planning system for mechatronic systems.

Web-based servers, services and applications are becoming key elements in the way many organizations deliver their services and provide support. Ensuring that expected performance and behavioral objectives are met is therefore critical. A commonly used approach is "application adaptation" which involves "tuning" the behavior of applications to meet the constrains imposed by their environments as well as their expected behavior. While there has been a lot of interest in applying classical feedback control theory in managing Web servers, the stochastic behavior of such systems compounded by complex interactions between the different tuning parameters, operational environment and load characteristics makes this task extremely daunting. On the other hand, policy-based management techniques offer flexible and adaptable means of dynamically changing systems' and applications' behavior without necessarily having to model the effects of the different possible configurations of the parameters. This paper looks at how such techniques can be applied to manage the performance of an Apache Web Server through the dynamic adjustment of tuning parameters. Several scenarios for evaluating the server's performance are presented which show that meeting the service level objectives (SLOs), such as response time, throughput, and the efficient utilization of CPU and memory, could be achieved with few and relatively simple policies.

Modern information systems are becoming more and more socio-technical systems, namely systems composed of human (social) agents and software(technical)systems operating together in a common environment. The structure of such systems has to evolve dynamically in response to the changes of the environment. When new requirements are introduced, when an actor leaves the system or when a new actor comes, the socio-technical structure needs to be redesigned and revised. In this paper, we propose an approach to dynamic reconfiguration of a socio- approach is based on planning techniques for generating possible alternative configurations, and local strategies for their evaluation. We present the reconfiguration mechanism that makes the socio-technical system self-configuring, and discuss and analyze the approach on a simple case study.

Denker, Schwartz et al. [10] start one of their famous papers with the sentence: ”Since antiquity, man has dreamed of building a device that would “learn from examples”, “form generalizations”, and “discover the rules” behind patterns in the data”.
Based on systems theory, especially on the framework of self-organization, a systematic approach how to build self-organizing networks based on a given set of trainings-data is shown. At first hand, the system is described in very general terms allowing application to a broad range of different networks. For a better understanding and in order to show the details, the approach is verified for the case of a 3-layer perceptron resulting in an algorithm thatshows how to construct perceptrons having the ability to classify a given set of patterns correctly. Performance at the standard test example “two–or–ore–clumps” is demonstrated.

This article presents a methodology suitable for analyzing self-organizing systems. The advocated methodology consists to model graphically the problem and verify it formally with B method. The methodology is constituted of three stages. The first one deals with using new model adapted at a self-organizing structure. That stage allows for a more intuitive description of the system’s behavior. The second one deals with translation rules that enable to go from the graphic model to a formal system specification. The third stage deals with the formal verification of the selforganizing process.
Our methodology is presented via the example of a self-organizing algorithm, where roles played by agents are at the heart of the self-organization itself.

The performance and dependability of grid computing can be affected due to manipulation of jobs results by malicious nodes. To assure correctness of applications, the grid environment needs to detect and isolate these kinds of nodes, self-organizing the set of available idoneous resources. This work presents a system-level diagnosis model based on comparison and reputation, which can be applied in several grid environments, as a strategy to avoid and minimize jobs results manipulation. This model settles the roles of the nodes according to their index of confidence, grouping them in autonomic logical clusters, where a hierarchy among the nodes is created to reach the diagnosis. Results achieved through simulation evaluate the model effectiveness in scenarios with different rates of malicious nodes.

An autonomic network must work unsupervised. Therefore it must be able to respond to unpredicted situations. The BIONETS project is investigating possible approaches for the production of network services that are able not only to perform short-term adaptations to the environment but also long-term evolution of new functionalities. To this end a bio-inspired approach is proposed, based on crossover or recombination of existing services to produce new generations of services which proliferate in the network or are discarded by a mechanism similar to natural selection. In this paper, we consider, from an engineering perspective, the problem of building self-evolving services in a pervasive computing environment. We try to individuate biological processes able to provide useful design guidelines for such systems and discuss various issues related to the translation of such models into a fully functional solution.

This paper proposes a self-organizing approach, based on ant-like agents, for the logical reorganization and the discovery of resources in Grids. Grid resources are assumed to be categorized according to their semantic features, and accordingly Grid users can search the network for resources belonging to a specific class. Metadata documents describing Grid resources are replicated and disseminated on the Grid by ant-like agents, in such a way that documents related to the same class are accumulated in restricted regions of the Grid. A semi-informed discovery protocol drives query messages towards a region in which a large number of resources belonging to the requested class are maintained. Both agents and query messages travel the network according to a system state, so guaranteeing scalability and robustness. Simulation analysis proves that the proposed approach allows for increasing the effectiveness of resource discovery, in terms of the mean number of discovered resources and time to collect them. This paper analyzes the impact that the granularity of resource categorization, i.e. the number of defined resource classes, has on performance results, and discusses benefits and drawbacks of having a more or less fine-grained resource categorization.

The software industry is faced with the fast growing complexity of IT infrastructures. This makes manual administration increasingly difficult and appears to be the limiting factor in the general development of such infrastructures. This complexity crisis has stimulated many researchers to propose software systems that are allegedly self-organizing. However, often, this claim is only based on vague intuitions about self-organization, and a proper classification is missing. From a scientific standpoint, this is questionable and undesirable since it adds confusion rather than clarity. In this article, we propose a framework that enables researchers to classify their systems and to state clearly, verifiably, and reproducibly why and in which way they are self-organizing. This framework provides a definition of the properties of a self-organizing system, it defines a respective class of systems denoted as SO, and it offers a methodology for showing that a given system is belonging to $SO$ or not. We present case studies of well-known existing software systems to show that our methodology is useful and practically applicable.

A self-organizing method to solve complex optimization problems as a graph vertex coloring is proposed in this paper. The self-organizing approach is needed in the environment of ad hoc networks because there is no central management and the network nodes can use only local information. The solution can be found only by local interaction between the system components without any help from outside. The proposed method is inspired by the chemical casting model but it is extended and more generalized. The method's accuracy is tested with instance graphs.

The advent and proliferation of Service-oriented Architectures (SOA) drives computing infrastructures into a highly interconnected, heterogeneous, and dynamic world. Conventional management tools fail in the attempt to deal with the heterogeneity and the dynamics associated with this type of information infrastructures. More and more researchers try to cope with the complexity, heterogeneity, and uncertainty by using technologies inspired by biological systems. A promising approach for managing such large-scale IT infrastructure is to provide capabilities for self-organization, which – to some extent – is analogous to the human autonomic system (as postulated in IBM’s Autonomic Initiative). This paper outlines a common view on Autonomic Service-oriented Architectures and proposes a way to get such an autonomic infrastructure. An outline of the differences between autonomic service-oriented architectures and other systems with autonomic properties is followed by a discussion of the existing enabling technologies and of missing pieces on the roadmap to a self-organizing infrastructure.

In this paper, we present how we extended the management system in JOnAS, an open source J2EE application server to introduce autonomic functions. This work required minimal modifications in the application server and is based on a standard component model, JMX. Therefore, our solution can be easily generalized to other application servers or JMX-based systems. To illustrate our approach, we describe a self-recovery experience we held in a J2EE cluster and we discuss the benefits and the drawbacks of our solution. adapt to external events without human intervention. Performance variation and failures are examples of external events that can occur at run time. This work can be tedious for legacy systems, like J2EE AS, since it can lead to an important modification in the system code. Furthermore, the legacy systems generally implement specified standards that have to be maintained in the modified code.

Systems and workload management frameworks have proven to be valuable utilities used to monitor and manage enterprise applications and the systems they run on. While these systems may have a great deal of knowledge about applications, they generally have little ability to control the rate at which applications receive work. In contrast, load balancers can control this rate, but typically have little information about the application’s ability to successfully handle the request. This paper describes recent efforts to unite these components in an autonomic manner for efficient, performance-oriented load balancing in enterprise environments. We will cover the interactions between these two components, an algorithm for autonomic, performance-based load balancing, and a brief case study involving this interaction with an enterprise application.

Since its creation in 1990, World Wide Web has increased the popularity of Internet which becomes an important source of information or services for all people over the world. The dynamic nature of the Web draws attention to the need for continuous support and updating of Web information retrieval systems. Web crawling is the process of discovery and maintenance of large-scale web data. Crawlers achieve this process by following the Web pages hyperlinks to automatically download a partial snapshot of the Web. In this paper, an agent- based approach, through three scenarios, for parallel and distributed Web crawling is presented. Simulations with ns2 show that the cloning based mobile agents scenario outperforms the single and multiple mobile agents scenarios.

Poster

In the last decade, due to emerging real-time and multimedia applications, there has been much interest for developing mechanisms to take into account the quality of service required by these applications. One of these mechanisms consists to integrate quality of service (QoS) in routing decision. Efficient outing of information packets in dynamically changing communication network requires that as the load levels, traffic patterns and topology of the network change, the routing policy also adapts. Making globally optimal routing decisions would require a central controller with complete information about the state of all nodes and links in the network, which is not realistic. An adaptive routing algorithm should efficiently explore and update routing information available at different nodes as it route packets. It should continuously evolve routing policies with minimum overhead on network resources. In order to take into account the dynamic’s change communication networks, we must to have interaction between nodes and the nature of quality of service needed by the transported flow. We focused in this paper on self-optimization of QoS by developing a neuro-dynamic programming to construct dynamic state-dependent routing policies. In this paper, we propose an approach based on adaptive algorithm for packet routing using reinforcement learning called K Shortest Optimal Path Q Routing Algorithm which gives much more better performances compared to standard shortest path, K-Shortest algorithm and Q-routing algorithms. To improve the distribution of the traffic on several paths, we integrate a probabilistic module in order to compute dynamically a probabilistic traffic distribution. This module takes into account the capacity of the queuing file in the router and the average packet delivery time. The performance of our algorithm is evaluated experimentally with OPNET simulator for different levels of traffic’s load and compared to standard shortest path and Q-routing algorithms on large interconnected network. Our approach prove superior to a classical algorithms and is able to route efficiently in large networks even when critical aspects, such as the link broken network, are allowed to vary dynamically.

We propose the Threshold-Based Energy Efficient Routing Protocol (TBEERP) for Wireless Sensor Networks. In this scheme, hard and soft threshold are set, and the data collected by sensor nodes are forwarded only if they are higher than the threshold value. The energy level of each node is broadcasted to all neighbors periodically and each individual node makes routing decisions according to a routing algorithm, which is sensitive to the residual energy level of the node. To prevent the node from receiving dupli-cate data, a route set which is composed of the nodes on the route is deployed and then the node only chose the neighbor node that is not in route set. To insure that the network delay is not too long, a parameter Ts is set. If the delay is longer than Ts, the data are dropped. To prolong the life time of the network, the activity of an exhausting node is reduced. Simulation results show that such routing mechanism has high robustness in terms of packet delivery ratio even in harsh link conditions. This scheme allows network planners to influence the routing decisions for adapting to a variety of network scenarios by adjusting parameters.

One of the key motivations for the provisioning of autonomic communication features in next generation services is to reduce the need of human inference for management tasks. This however means essentially that system control is delegated to the system itself, i.e. the system operator gives up control to a certain extent. The consequence is that autonomic systems might deviate from intended states and behaviours, may show inconsistent or unwanted ones. Based on Stefford Beers Viable System Model (VSM), we develop a methodology to define supervision structures as self-similar system enhancements to alleviate from those behaviours. The VSM provides us with an intellectual and methodological framework for self-management in autonomic systems and allows for an understanding of the relationship of those control structures to the hierarchical organization of the supervised system.

Current society is witnessing an age of computing ubiquity where the digital world is not longer limited to closed work, home or social environments but increasingly envelops every aspects of private and social life and their surroundings. However, if computing power is to serve us, and the converse is to be denied, then individual components and their rich panoply of services must be able to operate without significant intrusion. To achieve this, such services would require a high degree of supporting knowledge, including knowledge about the social, computational, and physical environments in which they are situated, as well as self-knowledge about their own functioning. While this provides the knowledge with which they can, eventually, manage and configure themselves it does also makes them more self-aware or in short it makes them smarter. However, in order to get 'smarter', the environment, its entities and services need some form of properly represented, well correlated and widely accessible repositories, which leads to the concept of self-organizes knowledge networks,focus of this work.

In this paper, we present local decision rules for autonomic service deployment, based on nonlinear dynamics and regulatory feedback loops. We then move on to describe a methodology to study global system dynamics and make quantitative predictions about service availability in a peer-to-peer community governed by these rules. The need for efficient differentiation is made obvious by the cost of resource reallocation.For example, in server farms, the cost of migrating a server from one application to the other (e.g. to respond to a fluctuation in demand) may be associated with the time required to reboot the machine and/or load a different set of software components, or by the delay incurred by the need to scrub the memory of any sensitive information [REF]. In these conditions, it becomes highly adaptive to be capable of inducing long-term specialisation, so as to reduce reallocation cost without sacrificing plasticity and adjustment of the offer to the demand. The motivation of this work is to demonstrate that,even in extreme conditions in which hosts are not characterised by a priori, explicit capabilities that could determine their future specialisation (i.e. they are are notionally equivalent “peers” in initial conditions), self-organisation can be used to promote such differentiation.

We expect that the future economy will be organised around networked and completely automated transactions between enterprises, and between individuals and enterprises. Thus it is important to understand how such systems may operate and how they would perform. Such systems will also have to operate in an opportunistic autonomic networking framework in order to be able to deliver uninterrupted economic services to large numbers of automated or live users. The purpose of this paper is to describe a framework for such systems using the paradigm of an automated networked auction operating on top of an autonomic network. This applies in particular to the application framework for the EU FP6 CASCADAS project.

An autonomic network must work unsupervised. Therefore it must be able to respond to unpredicted situations. The BIONETS project is investigating possible approaches for the production of network services that are able not only to perform short-term adaptations to the environment but also long-term evolution of new functionalities. To this end a bio-inspired approach is proposed, based on crossover or recombination of existing services to produce new generations of services which proliferate in the network or are discarded by a mechanism similar to natural selection. In this paper, we consider, from an engineering perspective, the problem of building self-evolving services in a pervasive computing environment. We try to individuate biological processes able to provide useful design guidelines for such systems and discuss various issues related to the translation of such models into a fully functional solution.

One of the key motivations for the provisioning of autonomic communication features in next generation services is to reduce the need of human inference for management tasks. This however means essentially that system control is delegated to the system itself, i.e. the system operator gives up control to a certain extent. The consequence is that autonomic systems might deviate from intended states and behaviours, may show inconsistent or unwanted ones. Based on Stefford Beers Viable System Model (VSM), we develop a methodology to define supervision structures as self-similar system enhancements to alleviate from those behaviours. The VSM provides us with an intellectual and methodological
framework for self-management in autonomic systems and allows for an understanding of the relationship of those control structures to the hierarchical organization of the supervised system.

Service Level Agreements (SLAs) provide a contract between an application user making demands on resources, and application providers determining what should be made available for external use. To enable resource sharing in multi-application environments, SLAs may be used to define: (i) requirements that such an application would place on resources (and services) owned by a third party; (ii) check whether these requirements have been met during use. An SLA must also encode some policy that specifies the penalty that a service provider may incur if terms in the SLA are violated. Currently, SLAs are defined in a static manner, i.e. the terms within an SLA must adhere to strict constraints, and monitored during application execution -- such as in WS-Agreement. However, within many scientific computing applications, it is often difficult to define such constraints very precisely -- thereby leading to a large number of violations. The need to modify an agreement that had already been established especially if the agreement is used at a time much later than when the agreement had been defined is necessary. These requirements relates to comparing the cost of re-establishing a new agreement vs. being able to adapt an agreement that is already in place. Secondly, there is need to support flexibility in the agreement if an agreement initiator is not fully aware of the operating environment when the agreement is defined. In this case, the agreement initiator may not have enough information to determine what to ask for from a provider. This is likely to be the case when an agreement initiator or provider operates with imprecise knowledge about the other party involved in the agreement. This talk will describe the need for such dynamic SLAs and identify possible mechanisms that may be used to define and manage them. Changes needed to WS-Agreement to develop such dynamic SLAs will also be discussed.

Many different natural and man-made objects have already been referred to as self-organizing. Natural examples are magnets, swarms and other animal societies, the brain and nervous systems and even the whole nature. Man-made examples are the web and scientific communities, firms, co-operatives and the market economy. After explaining some of them in more detail, several definitions for self-organization are presented. They result in a first generalizing look at the self-organizing objects as relatively isolated operationally closed systems. The internal structure and correspondingly the self-organizing processes of these systems however differ. We elaborate the following typology: equality (in flat - one layer - systems with random or determined or goal-seeking behavior of their elements as well as hierarchies of these flat systems); heterarchy; hierarchy; and combinations of these types in complex systems. And we explain mechanisms and rules which these different types of self-organization are following. Examples are order from noise; the slaving principle; tit-for-tat response and antagonistic control; principle of potential command; and bottom-up-top-down planning in hierarchical organizations.

Agent technology has been a promising new paradigm for the last 10 years now. However, unlike object oriented programming, it is not a general purpose solution that should be used for any application conceivable. Therefore, inevitably, agent systems will be connected to other software systems using other paradigms. The role of the agents in the overall application, however, can vary considerably. It ranges from a type of expert system module to sensors in a sensor network. Autonomy of the agents is usually seen as the main common feature. Although this is a nice feature it also poses the question of reliability in connection to other systems and predictability of the complete multi-agent system.
In this presentation I will show how multi-agent systems can be organized in order to deliver predictable outcomes and how the connection of the agents with their environment can be shaped depending on the role of the agents in the overall application.

The Service-oriented Architecture paradigm (SOA) is the current silver bullet expected to solve all enterprise computing problems once and for all, as many methodologies and technologies before. SOA promotes autonomy - through the separation of interface, implementation and location combined with the aspect of choreography for achieving higher-level computation. In an industrial setting these capabilities address only a very small set of the overall requirements of an agile enterprise software architecture. Aspects like modular modeling, separation of concern, transaction processing, scale-out requirements, change management and reliability are a few of the additional requirements that must be considered for enterprise computing. This presentation will paint an overall enterprise architecture picture for enterprise-class computing and shows the role SOA can play in it in the long run.

Emergent behaviour is a common phenomenon in multi-agent systems in which autonomous agents perform actions with only limited local information and making decisions individually while the whole system demonstrates properties and behaviours that have strong global features. A typical example of the applications of emergent behaviours is the self-organisation of autonomous agent communities. Because of the huge gap between individual agents' property and behaviour and those of the whole system, specifying and reasoning about emergent behaviours are notoriously difficult if not impossible. In this talk, I will report a recent attempt in the development of a formal theory, called Scenario Calculus, based on the formal specification language SLABS for logical analysis and formal proofs of the properties of emergent behaviours in multi-agent systems. It will be illustrated by examples such as autonomous sorting and a variety of self-organised agent communities.

During recent years the autonomic computing research and development community has made astonishing leaps forward with regard to defining and developing programming, control and interaction models to enable self* capabilities. This is reflected in the flurry of reports of a wide-industry uptake of the technology. Whilst, most of such effort has focused primarily “in-the-small” to enterprise scale systems self-management, research effort is now investigating scalable approaches to support large-scale autonomic networks of systems. However, in an inherently random network of autonomic systems with complex interactions, simply scaling up the prevailing model-based autonomic designs based on feedback and centralized control is reaching its limits. Hence, work is now underway exploring emerging theories of self-organising systems, statistical mechanics, complexity theory and random networks to name but a few.
In this talk, we start with a brief review of the state-of-the-art autonomic systems designs including; reference models, standards, distributed software engineering, and then introduce the technical challenges and limits of applicability of model-based approaches to designing and analyzing large-scale self-management IT systems. This will be followed by an overview of emerging theory of random and complexity networks and its application to modelling and understanding both structural and dynamic aspects of emergent autonomic behaviour. We present formal models for characterizing such networks supported by experimental results providing further insights into self-organisation and scaling properties of such networks. Finally, we conclude with a description of how these techniques can be implemented using illustrative examples of peer-to-peer grid based systems.

The messaging mechanism of Web Services is tending towards an agent paradigm which is based on very flexible addressing and semantics of the messages and communication protocols to serve macro objectives shared by participants. Recent improvements in Web Services make it possible to integrate agents and Web Services in a common messaging framework that includes both architectures integrally. The present work describes the integration based on the properties of both scenarios. The proposed integrated architecture is discussed and related work reviewed to conclude with a numerous set of research areas that are enabled by this elemental step.

Motivated by the increased bioinformatics service-based offering on the Grid, we envisage a new model for programming the Grid at a semantic, knowledge-based level of abstraction through theuse of argumentative agent technology. In this setting, agents are associated with roles of service requestors, service providers and brokers. This new model provides an enhanced service composition model for grid applications, whereby service requestors, providers and brokers can profit from the dynamic composition of Grid resources and services into executable workflows. This model would thus have considerable impact on existing business practices, by enhancing the role of Grid in current business applications. Within this model, argumentative agents are equipped with methods for negotiation with other agents. Agents act on behalf of their owners, be
it in the consumer, provider or broker roles, or a combination thereof. With the support of argumentation processes, they decide how to fulfill the demands of their owners by creating, managing and joining virtual organisations, understood as societies of agents, while pursuing their own goals.

Database oriented data grid becomes a new demand with the development of grid technology, and DS_Grid (DatabaSe oriented Data Grid) is such a grid system supporting dynamic data integration with the idea of service. In DS_Grid, MultiChord is adopted as the grid framework implementing the distributed storage, processing and data integration of data service resources and the domain and its corresponding data resources schema are specified according to text similarity definition to locate the peers data service resources registered, so as to improve the cover range of data service resources discovered, multi-root and multi-peer data resources replica management mechanism to improve the efficiency of discovering data service resources and the reliability and availability of DS_Grid, filter distributed data integration strategy is applied to reduce the traffic cost and the data integration cost, and distributed clustering analysis technology is realized to summarize the huge data information. The experiments have demonstrated the availability of the key technologies adopted in DS_Grid.

Service Oriented Architecture and Web Services provide an integration infrastructure for service workflow composition and execution. Many planning techniques can be facilitated to construct the service workflow at a building phase (planning), however, it is difficult and challenging to maintain the qualities of service workflow at execution phase, as the delayed response time, the limited throughput and service faults are common that often violate, or fail the service goals. Then service workflow re-planning should be in place in order to deal with the unpredictable situations during service workflow execution. In this paper, we consider an expansion-based replanning algorithm with the use of a limited change strategy. It addresses the problem of least affecting the original service workflow structure whiles the service goals of the workflow remains valid. We will show simulation results of the proposed replanning strategy based on experiments with service workflow replanning. The results of the simulation are analyzed for the consideration of further research.

GSEE - a grid-enabled value-added service platform in Next Generation Network NGN) - is proposed to solve the performance problem with traditional service platform of NGN. The value-added services hosted by GSEE are wrapped into grid services. GSEE and other nodes with spare processing capability are organized into virtual organization (VO). A task scheduling algorithm is proposedto overcome the performance bottleneck problem when system gets overload by leveraging existing resources in the same VO. GSEE is modeled by Stochastic Petri Net (SPN) in this paper. And simulation experiment is done based on this model, with the help of SPNP (stochastic Petri net package) to test the performance of GSEE. The simulation result verifies GSEE can really improve system performance.

An important aspect of managing service-oriented grid environments is management of agreement relationships between service providers and their customers. The key concept in addressing these agreements is service level agreement. In this paper we motivate the need for SLA lifecycle management in services grid and present results of our analysis on functional and non-functional requirements. Afterwards the state of the art in managing service level agreements is revisited by a comprehensive evaluation of current efforts and their respective strength and weaknesses in service level agreement lifecycle management systems. The results of this evaluation have been applied to the development of the open management platform Adaptive Service Grid which is an EU founded research project.

Web services have emerged as a popular technology for integrating distributed applications. A Web service composition is a description of how different Web services can interoperate in order to perform more complex tasks.
QoS for composite Web services has attracted interests from both research and industrial communities. In this paper, we propose an agent-based solution for the QoS composition problem using Distributed Constraint Satisfaction Problem (DisCSP) techniques. We show that by using the composition structures, local constraints can be constructed and used with DisCSP.We also present an enhancement of the Asynchronous Aggregate Search (AAS) algorithm to solve the problem and discuss our initial experiment in building a multi-agent system to prove the feasibility of our approach.

In ubiquitous environments, the content adaptable services can be dynamically provided to adapt the frequent changes of contexts. These services have common things that the kinds of context factors are limited to ubiquitous environment, though the contexts are flexible. To reuse service architecture can be reasonable for effective adaptable service. In this paper, we propose a reusable architecture with product line techniques for content adaptable applications in ubiquitous environment. It can describe reusable points for service and optimization policies. Description of reusable points is to define variation points and their variants and to find out the dependencies between them. Optimization policies are to build the variant selection strategies. These can accomplish to define the decision model based on content adaptable service, and to help the reuse more effective.

The inherent complexity of Grid application development is an obstacle to the widespread adoption of service oriented Grid technology. In this paper, a software development environment for service oriented Grid applications integrated into the Eclipse platform is presented. Its design is based on model-driven software development principles, allowing domain experts to rapidly develop Grid applications by hiding the complexities of Grid middleware. The functionality of the three main components supporting service creation, process creation and interactive debugging are presented, and implementation issues is discussed.

Apache Axis2 is the successor of the highly influential Apache Axis SOAP project. The new Axis2 architecture is highly flexible and supports many additional functionalities compared to Axis1. It is built around an XML object model called AXIOM. Axis2 also features a highly flexible model to support MTOM and asynchronous Web service invocations. In this tutorial we will briefly discuss the architecture and how services can be implemented or invoked by using Axis2. Examples of handlers and modules will also be presented to explain the pluggable architecture of Axis2.

Apache Axis2 is the successor of the highly influential Apache Axis SOAP project. The new Axis2 architecture is highly flexible and supports many additional functionalities compared to Axis1. It is built around an XML object model called AXIOM. Axis2 also features a highly flexible model to support MTOM and asynchronous Web service invocations. In this tutorial we will briefly discuss the architecture and how services can be implemented or invoked by using Axis2. Examples of handlers and modules will also be presented to explain the pluggable architecture of Axis2.

Description: The service orientation of software, that is, the decomposition of functionality into self-contained, well-defined services and their provision via service-oriented architectures, is currently one of the major trends in software development. As usual with trends and hypes, their benefits dominate the discussion, whereas the drawbacks and limitations are often not mentioned. In this tutorial, challenges for the migration of applications to service-orientation are critically discussed. To this end, an integrated approach for the development of service platforms, services, and service-oriented applications is presented. This general approach can be customized to different development situations and contexts; the possible cutomizations, as well as their impact on processes and organizations are presented.

Technological aspects of modern service-oriented architectures typically relate to approved web service standards, such as SOAP and WSDL. Due to the increasing non-functional demands for such environments, there is a need for standardized SOAP and WSDL extensions to cover topics like security, asynchronous messaging, transactional behavior or routing. The tutorial provides an overview of the according WS-* landscape, and provides practical experiences from the usage of these specifications and implementations in the ASG "Services Infrastructure" component. We will focus on the representation of stateful service instances, as well as on the appliance of service grid technologies in modern SOA environments

Metamodelling is often viewed as obscure and irrelevant for the daily work of software developers. To dispel this misconception this tutorial will demonstrate some advances in metamodelling techniques that make metamodelling affordable to developers and much more applicable and useful for their needs. The new techniques explained will include powertype-based metamodelling, the construction of methodologies using resources and templates from a method engineering perspective, the integration of process and modelling issues in the same metamodel and the incorporation of capability/maturity attributes at the methodological level. The Australian Standard AS 4651-2004 (as well as the ongoing ISO/IEC 24744 project) will be used as a reference framework.

Metamodelling is often viewed as obscure and irrelevant for the daily work of software developers. To dispel this misconception this tutorial will demonstrate some advances in metamodelling techniques that make metamodelling affordable to developers and much more applicable and useful for their needs. The new techniques explained will include powertype-based metamodelling, the construction of methodologies using resources and templates from a method engineering perspective, the integration of process and modelling issues in the same metamodel and the incorporation of capability/maturity attributes at the methodological level. The Australian Standard AS 4651-2004 (as well as the ongoing ISO/IEC 24744 project) will be used as a reference framework.

Method engineering promotes the idea of constructing methodologies for information systems development by selecting and assembling method fragments from a pre-existing repository. This repository needs first to be populated with self-contained fragments derived from industry best practices and compliant with a given metamodel. This tutorial will show how to construct a method fragment repository using a metamodel, how to obtain method fragments both from analysis of best practices and by extraction from existing methodologies), how to standardise the interfaces of these method fragments and how to construct tailor-made methodologies from these fragments.

Service Oriented Architecture paradigm promises to fill the environment with many small, reusable services that can be combined to perform a vast range of tasks. In order to make it happen some issues have to be solved. How to find adequate services? How to combine them? How the functionality of a real service should be described and represented?
This tutorial will elaborate on the advantages and drawbacks of SOA and trying to answer how state-of-the-art can be brought to a next level using the idea of Semantic Web services and the outcomes of the Adaptive Services Grid project. Besides some technological insights, the Semantic Web services lifecycle within the ASG platform will be discussed along with the ASG prototype of a Semantic Web Services environment.