Abdelhak Seriai

Quality-Driven Extraction of a Component-based Architecture from an Object-Oriented System

Software architecture modeling and representation became a main phase of the development process of complex systems. In fact, software architecture representation provides many advantages during all phases of software life cycle. Nevertheless, for many systems, like legacy or eroded ones, there is no available representation of their architectures. In order to benefit from this representation, we propose, in this paper, an approach called ROMANTIC which focuses on extracting the architecture of an object-oriented system. The main idea of this approach is to propose a quasi-automatic process of architecture recovery based on the quality characteristics of an architecture by formulating it as a search-based problem. This last acts on the space composed of all possible architectures abstracting the object-oriented system.

Search-Based Extraction of Component-Based Architecture from Object-Oriented Systems

Software architecture modeling and representation are a main phase of the development process of complex systems. In fact, software architecture representation provides many advantages during all phases of software life cycle. Nevertheless, for many systems, like legacy or eroded ones, there is no available representation of their architectures. In order to benefit from this representation, we propose an approach called ROMANTIC which focuses on extracting a component-based architecture of an existing object-oriented system. This approach considers this problem as a balancing problem of competing constraints which aims to select the best solution among all the possible architectures. Consequently, we present in this paper the identified constraints of this problem and its formulation as a search-based problem.

A self-adaptation of software component structures in ubiquitous environments

The creation of applications able to be executed in ubiquitous environments, involves a better consideration of the execution context in order to ensure service continuity. In component-based software engineering, applications are built by assembling existing components. For deploying such applications in ubiquitous environments, its components must be able to adapt themselves to the current context. To deal with this issue, we propose in this paper an approach aiming at reconfiguring the component structure to allow a flexible deployment of its services according to its use context. This adaptation focusing on the service continuity, consists of determining a structure adapted to the execution context. Then, the current structure is automatically reconfigured and the generated components are redeployed.

A Reuse-driven approach to update Component-Based Software Architectures

As the maintenance of software architectures emerges as a discipline within software engineering, it becomes increasingly important to propose new approaches to manage and facilitate it. In this paper we propose and describe the updating style as a reusable unit filling the gap between full-reusable solution and full-usable ones. Our updating styles aims at capitalizing update expertise, or know-hows, within component-based architectures for use and re-use purposes. An updating style is a family of update procedures dedicated to a business domain, sharing common tasks that have to be performed in the quite same order, to update a software architecture in a proven and safe way. The primary ideas of this research are: (a) an updating style is a building block to create increasingly complex update procedures by reuse; (b) an updating style is expressed on an architectural family, whose specific update procedures can be derived through instantiations; and (c) some updating styles can be run, after ad-hoc projections on environments

Dynamic Adaptation of Software Component Structures

We present in this paper an approach aiming at dynamically adapting a component structure while preserving its behavior and its services. Among the motivations of this kind of adaptation, we note its possible application to allow a dynamic redeployment of component services according to the available resources (e.g. CPU, memory). The run-time software component structural adaptation process is based on two phases. The first one consists in transforming this component by generating a dynamically adaptable component structure. This transformation is based on the analysis and the instrumentation of component code. The second phase of the adaptation process allows us to adapt the component dynamically by the reconfiguration of its internal structure

Software Component Re-engineering for their Runtime Structural Adaptation

Adapting software components to be used in a particular application is a crucial issue in software component-based technology. In fact, software components can be used in contexts with characteristics different from those envisaged when designing the component. To deal with this issue, we propose in this paper an approach aiming at adapting a software component structure in order to preserve service continuity. This adaptation, achieved by component fragmentation, allows its structure reconfiguration and its redeployment while preserving its behavior and its services. The structural adaptation process is based on two phases. The first one consists of the component re-engineering in order to introduce runtime adaptation facilities. The second phase, achieved since runtime, aims at reconfiguring the component structure according to the user needs.

Query reification based approach for object-oriented query formulation aid

We propose an approach facilitating query formulation for users sharing a common database. Our approach is based on two considerations. On the one hand, query formulation can be considered as a skill which can be shared entirely or partly between users. Accordingly we propose a model for storing and making available this skill to help users formulate their new queries. On the other hand we base our design on custom construction of a database adapted to each business group of users in question. In using it, the users of a given business cooperate transparently through their queries to design databases specific to their business. Thus, they take part co-operatively if indirectly in reducing the difficulty of query formulation.

SASE 2008: First Workshop on Self-Adaptive Software Engineering

The goal of this workshop is to exchange opinions, advance ideas, and discuss the state of the art of approaches and results among researchers and practitioners who investigate software engineering concepts, methodologies, and tools to design and evolve self-adaptive software. Adaptability is considered as a critical enabling capability for many software-based systems, which must adapt themselves to changing conditions in both the supporting computing and communication infrastructure, as well as in the surrounding physical environment.

Adaptation of monolithic software components by their transformation into composite configurations based on refactoring

We present in this paper an approach aiming at adapting component structures instead of adapting component services. It focuses on transforming a software component from a monolithic configuration to a composite one. Among the motivations of this kind of adaptation, we note its possible application to permit flexible deployment of software components and flexible loading of component service-code according to the available resources (CPU, memory). This adaptation is based on the analysis and the instrumentation of component codes.

Code Generation from Architectural Multiviews Description.

The software architecture of a system defines its high-level structure, exposing its gross organization as a collection of interacting components. It typically plays a key role as a bridge between requirements and code. Practitioners have come to realize that having a good architectural design is a critical success factor for complex system development. To improve design at architectural level, we have proposed a description model based on the view notion. Through this model, it is possible to describe both components and connectors according to several views. In this paper, we deal with the code generation from architectural specification obtained via our multiviews description model.