Abdelhak-Djamel Seriai

Feature-to-code traceability in a collection of software variants: Combining formal concept analysis and information retrieval

Today, developing new software variant to meet new demands of customers by ad-hoc copying of already existing variants of a software system is a frequent phenomenon in the software industry. Typically, maintaining such variants becomes difficult and expensive over the time. To re-engineer such software variants into a software product line (SPL) for systematic reuse, it is important to identify source code elements that implement a specific feature in order to understand product variants code. Information Retrieval(IR) methods have been used widely to support this purpose in a single software. This paper proposes a new approach to improve the performance of IR methods in a collection of similar software variants. Our proposal produces following two improvements. First, increasing the accuracy of IR results by exploiting commonality and variability across software variants. Secondly, increasing the number of retrieved links that are relevant by reducing the abstraction gap between feature and source code levels. We have validated our approach with a set of variants of two different systems. The experimental results showed that the proposed approach outperforms the conventional application of IR as well as the most relevant work on the subject.

Recovering Architectural Variability of a Family of Product Variants

A Software Product Line (SPL) aims at applying a pre-planned systematic reuse of large-grained software artifacts to increase the software productivity and reduce the development cost. The idea of SPL is to analyze the business domain of a family of products to identify the common and the variable parts between the products. However, it is common for companies to develop, in an ad-hoc manner (e.g. clone and own), a set of products that share common functionalities and differ in terms of others. Thus, many recent research contributions are proposed to re-engineer existing product variants to a SPL. Nevertheless, these contributions are mostly focused on managing the variability at the requirement level. Very few contributions address the variability at the architectural level despite its major importance. Starting from this observation, we propose, in this paper, an approach to reverse engineer the architecture of a set of product variants. Our goal is to identify the variability and dependencies among architectural-element variants at the architectural level. Our work relies on Formal Concept Analysis (FCA) to analyze the variability. To validate the proposed approach, we experimented on two families of open-source product variants; Mobile Media and Health Watcher. The results show that our approach is able to identify the architectural variability and the dependencies.

Mining features from the object-oriented source code of software variants by combining lexical and structural similarity

Migrating software product variants which are deemed similar into a product line is a challenging task with main impact in software reengineering. To exploit existing software variants to build a software product line (SPL), the first step is to mine the feature model of this SPL which involves extracting common and optional features. Thus, we propose, in this paper, a new approach to mine features from the object-oriented source code of software variants by using lexical and structural similarity. To validate our approach, we applied it on ArgoUML, Health Watcher and Mobile Media software. The results of this evaluation showed that most of the features were identified1.

Reverse engineering reusable software components from object-oriented APIs

Object-oriented Application Programing Interfaces (APIs) support software reuse by providing pre-implemented functionalities. Due to the huge number of included classes, reusing and understanding large APIs is a complex task. Otherwise, software components are accepted to be more reusable and understandable entities than object-oriented ones. Thus, in this paper, we propose an approach for reengineering object-oriented APIs into component-based ones. We mine components as a group of classes based on the frequency they are used together and their ability to form a quality-centric component. To validate our approach, we experimented on 100 Java applications that used four APIs.

Mining reusable software components from object-oriented source code of a set of similar software

One of the most important approaches that support software reuse is Component Based Software Engineering (CBSE). Nevertheless the lack of component libraries is one of the major obstacles to widely use CBSE in the industry. To help filling this need, many approaches have been proposed to identify components from existing object-oriented software. These approaches identify components from singular software. Therefore the reusability of these components may be limited. In this paper, we propose an approach to mine reusable components from a set of similar object-oriented software, which were developed in the same domain, ideally by the same developers. Our goal is to enhance the reusability of mined components compared to those mined from single software. In order to validate our approach, we have applied it onto two open source Java applications of different sizes; small and large-scale ones. The results show that the components mined from the analysis of similar software are more reusable than those which are mined from single ones.

Migrating large object-oriented Applications into component-based ones: instantiation and inheritance transformation

Large object-oriented applications have complex and numerous dependencies, and usually do not have explicit software architectures. Therefore they are hard to maintain, and parts of them are difficult to reuse. Component-based development paradigm emerged for improving these aspects and for supporting effective maintainability and reuse. It provides better understandability through a high-level architecture view of the application. Thereby migrating object-oriented applications to component-based ones will contribute to improve these characteristics (maintainability and reuse). In this paper, we propose an approach to automatically transform object-oriented applications to component-based ones. More particularly, the input of the approach is the result provided by software architecture recovery: a component-based architecture description. Then, our approach transforms the object-oriented source code in order to produce deployable components. We focus in this paper on the transformation of source code related to instantiation and inheritance dependencies between classes that are in different components. We experimented the proposed solution in the transformation of a collection of Java applications into the OSGi framework. The experimental results are discussed in this paper.

Software architecture recovery process based on object-oriented source code and documentation

Architecture recovery aims at providing a high level abstraction of a system using the architectural elements to represent functionalities and interactions. This architecture makes easier the program comprehension and then provides many advantages during all the phases of software life cycle. Nevertheless, most architecture recovery approaches fail to combine the human expertise on the system with a high automation level. In order to solve this issue, we propose to use the intentional architecture of a system, which represent the system as imagined by its designers, to improve the adequation between the resulting software architecture and the architects expectations without requiring more human expertise. Thus, we present in this paper a semi-automatic process to recover intentional architecture from the available documentation and the expert recommendations. This process is an extension of ROMANTIC, an approach aiming at recovering a component-based architecture of an existing object-oriented system.

Recovering software product line architecture of a family of object-oriented product variants

Software Product Line Engineering (SPLE) aims at applying a pre-planned systematic reuse of large-grained software artifacts to increase the software productivity and reduce the development cost. The idea of SPLE is to analyze the business domain of a family of products to identify the common and the variable parts between the products. However, it is common for companies to develop, in an ad-hoc manner (e.g. clone and own), a set of products that share common services and differ in terms of others. Thus, many contributions are proposed to re-engineer existing product variants to a software product line. Nevertheless, these contributions are mostly focused on managing the variability at the requirement level. Few contributions address the variability at the architectural level despite its major importance. Starting from this observation, we propose an approach to reverse engineer the architecture of a set of product variants. Our goal is to identify variability and dependencies among architectural-element variants. Our work relies on formal concept analysis to analyze the variability. To validate the proposed approach, we experimented on two families of open-source product variants; Mobile Media and Health Watcher. %The results show that our approach is able to identify the architectural variability and the dependencies.

Concept lattices: A representation space to structure software variability

Formal Concept Analysis is a theoretical framework which structures a set of objects described by properties. Formal Concept Analysis is a classification technique that takes data sets of objects and their attributes, and extracts relations between these objects according to the attributes they share. This structure reveals and categorizes commonalities and variability in a canonical form. From this canonical form, other structures can be derived, that can be more or less complex. In this paper, we revisit two papers from the literature of the software product line domain. We point to key contributions and limits of the representation of variability by concept lattices, with illustrative examples. We present tools to implement the approach and open a discussion.

Mining Software Components from Object-Oriented APIs

Object-oriented Application Programing Interfaces (APIs) support software reuse by providing pre-implemented functionalities. Due to the huge number of included classes, reusing and understanding large APIs is a complex task. Otherwise, software components are admitted to be more reusable and understandable entities than object-oriented ones. Thus, in this paper, we propose an approach for reengineering object- oriented APIs into component-based ones. We mine components as a group of classes based on the frequency they are used together and their ability to form a quality-centric component. To validate our approach, we experimented on 100 Java applications that used Android APIs.