Noureddine Belkhatir

Software process model and work space control in the Adele system

It is argued that the most critical aspects for modeling and control, in a large software engineering environment, are inter/intrateam communication and synchronization. A solution based on a two-level approach is proposed. The Adele kernel supports multiple activities on shared objects, providing services like contextual behavior, active relationships, and general process support. The second level is the TEMPO formalism based on the role concept, which defines a software process step as a set of objects playing a role. Each objects characteristics and behavior depend on the role it plays in the software process it belongs to, and may be part of different simultaneous software processes. TEMPO clearly separates the description of the process from the description of the interaction and collaboration between the different processes.<<ETX>>

Software management constraints and action triggering in the Adele program database

We present in this paper some extensions to the data base of the Adele program. We define the notion of event, and the simple language which allows one to express the association between an event and actions. The actions are executed automatically when the event is raised. It is shown, using examples on recompilation policies, how this simple mechanism can be used to express and enforce the semantics of relations, to control and manage propagation, to easily program software management policies and constraints and finally how such a data base can be used as the kernel of a software engineering environment.

A Metamodel-Based Approach for the Dynamic Reconfiguration of Component-Based Software

Non-stop and highly available applications need to be dynamically adapted to new conditions in their execution environment, to new user requirements or to some situations usually unpredictable at build-time. Bank, aeronautic, mobile and Internet applications are well known examples of applications requiring the dynamic reconfiguration. On the other hand the development complexity and cost constitute an important problem for the creation of applications supporting to be dynamically reconfigured. The work we present in this paper is centered around the dynamic reconfiguration of component-based applications. It is dedicated to describing DYVA, a virtual dynamic reconfiguration machine. The virtual aspect of DYVA means its independence from a particular application or a particular component model, which enhances its genericity and its reusability.

Adapting applications on the fly

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.

Supporting reuse and configuration for large scale software process models

A software process is a set of activities that will be carried out over time to produce a software system. Research on the software process has been increasingly recognized. This position advocates the representation of a software development process which should be explicitly defined, maintained and executed by a PSEE (Process Sensitive Software Engineering Environment). The complexity and scope of large scale process models makes their design, development and maintenance very complex. The overall objective of our approach is to define a tool to support the software process model construction and maintenance in PSEE. We investigate how software configuration management techniques applied to the software process can provide a novel solution for the definition and composition of reusable software process components. We present the current status of our work.

A Generalized Multi-View Approach

It is advocated here that integrating abstraction and modularity into the concept of point of view, and extending the view concept to the process itself (and not only to data used by processes), provides an uniform conceptual framework for aspects like agent point of view, quality models and process monitoring.

Improving Software Process Modelling and Enactment Techniques

Most of the work previously carried out on software processes addressed the problem of modelling as a monolithic description focusing on one perspective e.g. product, process, role, etc. Little has been done to address the problem of software process modelling through the dynamic composition of consistent and reusable pre-composed components. To build software processes from components, there are many concerns to take into consideration: 1) building a software information base of reusable components, 2) determining the components that make up a process model, while this composition is achieved dynamically to assure the mutual consistency of components, 3) how to achieve integration to support full product, activity and role perspectives, 4) how to incrementally construct the model by introducing new components or updating component versions in order to deal with evolution.

Providing Highly Automated and Generic Means for Software Deployment Process

We present a new approach for the management and enactment of deployment process by a deployment processor ORYA (Open enviRonment to deploY Applications). ORYA aims to integrate technology relevant to process support in deployment systems. The supposed context is a large scale networked organization. The deployment processor called ORYA provides deployment functionalities to distributed, autonomous, reactive processing entities representing workstations and servers. Based on these functionalities deployment processes can be enacted and monitored in an efficient manner. In this paper we focus on the distributed, multi-server, multi-client sites architecture of ORYA and the evaluation of its application to a real industrial case study dealing with a large transportation information system.

Model-driven framework for dynamic deployment and reconfiguration of component-based software systems

Permanent and uninterrupted functioning can be sometimes a requirement for some kinds of software systems. This is especially true in the case of complex and distributed systems where stopping and restarting the system constitute a tedious and costly task, also when the system must be highly available or when its execution environment changes frequently. Many component technologies exist today and solve hot (dynamic) deployment and reconfiguration issues offering ad-hoc solutions. This paper presents DYVA, a unified framework, that has been designed to be suitable to dynamic deployment and reconfiguration for most of the currently component technologies. Components from these technologies have to satisfy common features like en-capsulation, interfaces, etc...). The proposed framework is based on a model-driven approach. This approach helps in developing specific hot deployment and reconfiguration systems by the personalization of the unified framework. The personalization is done via plug-ins which make transformation between specific component descriptions and more general ones.

Supporting software maintenance evolution processes in the Adele system

One of the major problems encountered when developing large systems is related to maintaining an operational and responsive software system, once it has been accepted and put into production. This problem is referred to as Software maintenance. Evolution is central to Software Maintenance, responsible for ensuring a longer working life. Many Software Engineering Environments (SEEs) have been constructed in order to support maintenance activities. In this paper, we will first present major development in SEEs to support Maintenance. Afterwards, we will describe the main ideas behind the design and implementation of the ADELE system, a third generation SEE. Following this, we will give an example to illustrate the way a process model can be described on top of ADELE using an example of evolution maintenance. This approach is heavily based on event-condition-action formalism. We will illustrate the way in which communication and coordination of the activities carried out by different users are automated.