Summary form only given. Adapting a component-based application means adapting one or more of its components, and in general, adapting a component at run-time means disconnecting it from the application and connecting a new version of this component. Many approaches like OLAN and DCUP are based on component models in which each component is constituted by a functional part and a control part. This last part provides a set of services to administrate the component. In our approach we aim to separate the control part outside the component. The benefit is the possibility to apply our solutions to existing models that have not been designed to support the dynamic adaptation. Through a first experimentation on the JavaBeans component model, we define an adaptation process composed of several steps: (1) defining the mapping rules between the old and the new component (correspondence between properties and services); (2) passivating the old and the new components; (3) transferring the state of the old component into the new one according to the mapping rules defined before; (4) disconnecting the old component and connecting the new one; (5) activating the new component. These steps may constitute the basic activities of an adaptation machine.

Software process evolution corresponds to the act of improving the existing prescriptive software process models in a controlled and supported way. As software processes change constantly, it is therefore necessary to support one or more methods for assisting environment administrators in improving models. Changes are made in order to adapt software process models to new requirements, correct inconsistencies encountered in the course of execution, and modify, add or remove certain constraints. This article shows how software process evolution as supported in Tempo, a process-oriented software engineering environment where software processes are formally described in an object-oriented process schema. In Tempo, a process schema is comprised of descriptions of software agents, software products and software processes. A new approach is presented which supports the dynamic evolution of software process descriptions. In this approach, software process change is the result of tailoring the behavior of software objects manipulated during software process enaction.>

After years using of Adele, a configuration management system, it became apparent that it lacks activity-related concepts and mechanisms like work environment control, user coordination and synchronization, method and tool control, etc. It was also clear that considerable work is required to adapt a Software Engineering Environment (SEE) to user requirements. Using this experience, Adele 2 has beeen implemented to provide a general support for defining and managing dynamic aspects of a SEE and facilitate the building of new SEEs. This paper describes, using an example (work space control), the concepts and mechanisms involved. We show how close integration of an activity manager with a software engineering database fulfills the basic requirements and how a high level task manager coupled to a configuration manager can be developed.

Abstract Software maintenance is responsible for approximately 80% of the total cost of software. In order to reduce maintenance costs by improving both software productivity and quality, several software engineering environments have been built. In this paper, we present the main characteristics of Adele system, showing how this system is able to take account of software maintenance problems. We concentrate on the ability of this system to accept the specification of project‐specific policies and how these policies can be enforced automatically. We illustrate this with examples which with software maintenance. The second example is presented in the annexe and shows an example of cooperative work in an aerospace company. We conclude this article by presenting the lessons learned using our approach and our projects for the future.

TEMPO, a process-centered software engineering environment, assists in cooperative work by means of an approach based on a communication model. The executable formalism used to define software engineering activities is described, and it is shown how constraints related to the use of objects in these activities are expressed using the role concept. The communication model is then presented. Thanks to this model, strategies governing the cooperation between various software processes are specified by the concept of active, programmable connections. A connection is a communication channel that links two roles. Message exchange is controlled using TECA (temporal event-condition-action) rules, executed by a trigger mechanism. These allow for the programming of synchronization strategies between processes, propagating the effects of an executed action on one or more connection points. The temporary modes of TECA rules allow for transactions of long duration, because these can be used to reason on past activities. Coherence control of objects handled by activities of long duration is performed by the work environments. The union between connections and work environments makes it possible to support the cooperating processes and object sharing between processes.>