Capitalising on previous work on building systems from existing components that allow neither code inspection nor change, an architectural approach for treating faults through self-adaptation is outlined that, instead of providing mechanisms and techniques at the component level, relies on the interactions between components for obtaining flexible software structures that are nevertheless robust to the occurrence of undesirable events.

Abstract. Dynamic adaptation has become an essential feature in distributed applications, mainly because current technology enables complex tasks to be performed by computers in application domains unsuited for service interruption. This paper presents an infrastructure that uses an interpreted language to provide simple but powerful features that enable coarse and fine-grained adaptations in component-based systems, using the CORBA Component Model (CCM) as a basis. To extend the static nature of CCM, we propose dynamic containers, which enable development of dynamically adaptable components that admit changes on component structure and implementation. The extended set of mechanisms for component manipulation can be used to create adaptation abstractions that simplify the programmer’s task. In this paper, we present a tool that provides support for the protocols and roles abstractions, which allows programmers to adapt running applications, establishing new interactions among its components. 1

In this paper, we present an approach to feature modelling and composition that relies on the use of what we call “coordination technologies ” – a set of modelling primitives, design principles, design patterns, and analysis techniques that we have been developing for supporting the construction and evolution of complex software systems

tion (e.g., a call to a method of one participant), and a rule body stating what to do in that case. Contracts are also unaware of the existence of other contracts. This facilitates enormously incremental system evolution, because explicit dependencies between the di#erent parts of the system are kept to a minimum, and new contracts can be defined and added to the system at any time (even run-time), thus coping with changes that were not predicted at system design time. Consider the banking domain, in which ATX Software has several years of experience. Usually, there is an object class account with an attribute balance and a method withdrawal with parameter amount. In a typical implementation one can assign the guard balance#amount restricting this method to occur in states in which the amount to be withdrawn can be covered by the balance. However, as explained in [2], assigning this guard to withdrawal can be seen as part of the specification of a business requirement and not necessa

To achieve the high levels of evolution and personalization that current information systems have to deliver, we propose to separate four generic aspects: the computations the system has to perform, the interactions that are possible among those computations, the configuration of those computations and interactions into a coherent system, and the contexts of using the system. Each context provides a principled and personalized way of interacting with the system. Such interactions not only change the system state but may also lead to (run-time) changes in its configuration. We sketch some ideas on a four-layer architecture for the design of such agile systems.

Software evolution is, ever more, a critical concern for most business organizations. In spite of many promises, software development techniques, such as Object-Oriented ones, have fallen short of addressing this problem. We show how new technologies based on the notion of “coordination contract” can be deployed for managing the levels of change imposed by the evolution of requirements and technological environments, both in terms of semantic modeling and tool support.

The Web Services need to extend beyond the basic service architecture (invoke and respond) to selfcoordinating Web processes collaborating among themselves in the desired configuration as per user's application (transient to long lasting). A core set of artifacts are needed to allow these Web processes to hook together in a desired structure to enforce automatic information flow, group constraint satisfaction, and data and control dependencies, all without any central coordinating authority. We propose Web Coordination Bonds, analogous to the chemical bonds, as a set of such core artifacts for effective collaboration among Web Services. There are two types of Web bonds: subscription bonds allow information, control and event flows whereas negotiation bonds enforce dependencies and contracts. Web bonds are simple yet powerful, and we demonstrate how they can be employed to create (model) and enforce (deploy and execute) producerconsumer and shared-resource relationships, workflow scenarios, and atomic transactions. We have developed and prototyped a middleware called System on Devices (SyD) incorporating Web bonds, and have employed it to prototype a few distributed applications which bond existing Web Services together to collaborate. Much remains to be done, including theoretical treatment of Web coordination bonds.

. The separation between computation and coordination offers the possibility for systems to be evolved through the addition, deletion or substitution of the connectors that coordinate the interaction between their components, without interfering with the computations that are performed locally. Ideally, this form of evolution should be applicable regardless of the languages in which these computations are programmed, thus allowing for the integration of third-party, closed components, like legacy systems. In order to establish universal principles that support this level of generality, we propose a mathematical pattern that clarifies essential mechanisms of coordination that support evolution, and a design pattern that allows for such mechanisms to be implemented in platforms for component-based system development like CORBA, EJB and COM. 1

This paper reports on the use of coordination contracts, presented at the previous two IWPSE workshops, in a project for a credit recovery company. We have designed and implemented a framework that allows users to define several business rules according to pre-defined parameters. However, some rules require changes to the services provided by the system. For these, we use coordination contracts to intercept the calls to the underlying services and superpose whatever behaviour is imposed by the business rules applicable to that service. Such contracts can be added and deleted at run-time. Hence, our framework includes a configurator that, whenever a service is called, checks the applicable rules and configures the service with the given parameters and contracts, before proceeding with the call. Based on our experience, we put forward the position that coordination contracts facilitate the evolution of the system in order to accomodate new business rules that change the “normal ” behaviour of the provided system’s functionalities.

We describe a form of method-call interception (MCI) that allows the programmer to superimpose extra functionality onto method calls at run-time. We provide a reference semantics and a reference implementation for corresponding language constructs. The setup applies to class-based, statically typed, compiled languages such as Java. The semantics of MCI is used to direct a language implementation with a number of valuable properties: simplicity of the implementational model and run-time adaptation capabilities and static type safety and separate compilation and reasonable performance. Our implementational development employs sourcecode instrumentation. We start from a naive implementational model, which is subsequently refined to optimise program execution. The implementation is assessed via benchmarks.