A Software Product Line (SPL) represents a family of products in one domain. It is often specified through a feature model representing the end-user system characteristics. Most proposed feature model construction methods examine a set of product variants code to identify common blocks of elements each of which represents a feature. In this identification process, they adopt different similarity measures and clustering techniques. Consequently, they differ in the granularity and cohesiveness of the identified features, which in turn affect the structure of the constructed feature model. Evidently, this difference also impacts the reuse of the SPL when deriving a new product. This paper compares widely adopted textual clustering techniques in terms of the recall and precision in their identification of the features. More specifically, it experimentally examines Latent Semantic Indexing (LSI), Principal Component Analysis (PCA), Support Vector Machine (SVM)and Term Frequency-Inverse Document Frequency (TF-IDF). The experimental results showed that LSI has better performance than the other textual similarity techniques with an average precision rate of 68.6

Software enhancement must be carefully planned and quantified to satisfy customer change requests, such as adding a new functionality, or deleting or changing an existing one. This paper investigates the use of M5P Machine Learning (ML) algorithm on predicting software enhancement effort. This M5P ML algorithm is trained and tested with 302 software enhancement projects obtained from the ISBSG dataset. The correlation-based feature selection (CFS) algorithm is used to achieve efficient data reduction. Thus, the selected ML techniques are trained on a dataset with relevant features that lead to improve the accuracy of their estimates. The Performance of the M5P using CFS is compared with the three Machine Learning Regression Methods (MLRM): Gradient Boosting Regression (GBRegr), Linear Support Vector Regression (LinearSVR), and Random Forest Regression (RFR). Results show that the prediction of Software Enhancement Effort using Correlation-based Feature Selection and M5P is improved in terms of MAE (Mean Absolute Error) = 0.0612 and Root Mean Square Error (RMSE) = 0.2514.

Detecting code smells is an important research problem in the software maintenance. It assists the subsequent steps of the refactoring process so as to improve the quality of the software system. However, most of existing approaches have been limited to the use of structural information. There have been few researches to detect code smells using semantic information although its proven effectiveness in many software engineering problems. In addition, they do not capture entirely the semantic embedded in the source code. This paper attempts to fill this gap by proposing a semantic-based approach that detects bad smells which are scattered at different levels of granularity in the source code. To this end, we use an Abstract Syntax Tree with a Variational Auto-Encoder in the detection of three code smells. The code smells are Blob, Feature Envy and Long Method. We have performed our experimental evaluation on nine open-source projects and the results have achieved a considerable overall accuracy. To further evaluate the performance of our approach, we compare our results with a state-of-the-art method on the same publicly available dataset.

Software product lines (SPLs) identify and manage the commonalities and variability, called features, among the variants of products in a given domain. This reuse technique improves productivity factors such as reducing costs and time to market while enabling the derivation of particular applications that meet customers' needs by reusing the domains' artifacts. In this paper, we tackle the problem of SPL extraction from language-independent functional descriptions of existing product variants. Our contribution consists in synthesizing the SPL feature model from possibly incomplete requirements (use case diagrams, scenarios and functional requirements) of the product variants. To validate our approach, we applied it on five case studies: ArgoUML-SPL (small-scale system), Mobile Media-SPL and Messaging-SPL (medium scale systems), Health complaint-SPL and Crisis management-SPL (large scale systems). For this purpose, we used several releases from these domains as the considered product variants. Then, we applied our approach and evaluated its efficiency through measurements.

The reuse of design in the software product line (SPL) domain brings many benefits because it permits a clear understanding of the SPL. These SPL contain a set of common elements and a set of variable elements known as features. One of the main difficulties for representing SPL design is the variability. In order to express the variability in a SPL design and to reinforce its comprehension, it is necessary to define a design language that aims to model SPL and to distinguish the commonalities and variability. Accordingly, we present in this paper a new profile containing UML extension named SPL-UML that offers extended diagrams enriched by the information extracted from the feature models which lets us differentiate between the common points and variabilities of the SPL. The coherence between the proposed extensions is then ensured by OCL (Object Constraint Language) constraints. Finally, the UML extensions are illustrated using an example of TextEditing System.

Feature models (FMs) are widely used to describe software product lines (SPL). They specify common and variation points in the domain of the SPL. Because of their wide domain coverage, FM development requires extensive domain analysis and important domain expertise that is often hard to acquire. These development requirements motivated us to propose, in this paper, a top-down method that extracts automatically an FM from functional requirements of product variants. Besides its automation, its novelty stems from the use of semantic information mined through natural language processing techniques to extract potential features from each product variant. To account for name variations, our method harmonizes the names of the features extracted from the product variants by using a classification technique to group similar features. In addition, to determine the feature type, it uses the formal concept analysis technique to distinguish mandatory from optional features. Furthermore, to structure the FM, it uses a set of semantic criteria to determine the constraints among the features. The paper reports on a quantitative and a comparative evaluation of the method on existing FMs, and it examines the conformity of the generated FMs to the input functional requirements, based on experts’ feedbacks.

Software Product Lines (SPL) offer the ability to create, maintain and evolve a set of similar products with the simplicity of a single system rather than the complexity of deploying a multitude of products. It is well recognized by the research community interested in SPLs that designing SPLs with the standard UML language do not provide for a clear understanding of the SPL. This motivated us to propose SPL-UML, a profile that models the variability in UML designs for software product lines (SPL). The profile offers extended diagrams enriched by the information extracted from the feature models that lets you differentiate between the common points and variabilities of the SPL. Our profile is illustrated through its application in the design of a Mobile Media SPL.

The use of domain-specific design patterns improves substantially software quality and reduce the development cost since they capture domain knowledge and provide solutions of non trivial design problems in a specific domain. In order to benefit from these advantages, these patterns must be correctly instantiated by application designers. When a pattern is deployed in an application design, some constraints must be preserved to make the pattern instantiation valid. Accordingly, assistance for domain-specific design patterns instantiation has great significance. In this paper we propose a pattern instantiation process that guides the application designers in patterns reuse and prevents them from violating pattern constraints. We implement the proposed process based on model transformation as plug-in to the Eclipse modeling environment. Our proposal is especially intended for the reuse of patterns specific to real-time domain.

Several real-time embedded system must be dynamically reconfigured to account for hardware/software faults and/or maintain acceptable performances. Depending on the run-time environment, some reconfigurations might be unfeasible, i.e., they violate some real-time constraints of the system. In this paper, we deal with the development of dynamically reconfigurable embedded systems in terms of the production of execution schedules of system tasks (feasible configuration) under hard real-time constraints. More specifically, we propose an approach that starts from a set of reconfigurations to construct a Software Product Line that can be reused in a predictive and organized way to derive real-time embedded systems. To make sure that the SPL offers various feasible reconfigurations, we define an intelligent agent that automatically checks the system's feasibility after a reconfiguration scenario is applied on a multiprocessor embedded system. This agent dynamically determines precious technical solutions to define a new product whenever a reconfiguration is unfeasible. The set of products thus defined by the agent can then be unified into an SPL. The originality of our approach is its capacity to extract, from the unfeasible configurations of an embedded system, an SPL design enriched with real-time constraints and modeled with a UML Marte profile. The SPL design can assist in the comprehension, reconfiguration as well as evolution of the SPL in order to satisfy real-time requirements and to obtain a feasible system under normal and overload conditions.

An automated change impact analysis and management approach is vital to handle the complexity of adapting software during its evolution.Such an approach reduces the maintenance cost and provides for adequate decision making when confronted with the choice of accepting or ignoring changes.This paper presents a change impact management approach between UML models.It verifies the consistency and the quality of interdependent diagrams after a change is handled.In addition, it calculates the effort required in managing any change and displays a report indicating to the designer all necessary modifications to keep the design coherent.The approach is supported by a toolset, called CQV-UML tool.

Software Product Lines (SPL) ensure predictive and organized software reuse. In practice, SPL are often set up after several similar product variants have been in use. This practical fact prompted a quest for bottom-up processes that start from existing the source of product variants to identify a product line. This later is then described with a feature model that essentially specifies the components of the SPL and their variability within the product family. However, so far proposed notations for feature models do not provide for a clear understanding of the SPL nor do they guide in their maintenance and future evolution. These shortages motivated us to propose a bottom-up approach that extracts from the source code of product variants, the SPL design enriched with information extracted from the feature model. The enriched SPL is modeled with a UML profile that assists in the comprehension, reuse as well as evolution of the SPL.

International audience

Design patterns capitalize the knowledge of expert designers and offer reuse that provides for higher design quality and overall faster development. To attain these advantages, a designer must, however, overcome the difficulties in understanding design patterns and determining those appropriate for his/her particular application. On the other hand, one way to benefit from design patterns is to assist inexperienced designers in pattern detection during the design elaboration. Such detection should tolerate variations between the design and the pattern since the exact instantiation of a pattern is infrequent in a design. However, not all variations of a pattern are tolerated. In particular, some structural variations may result in non-optimal instantiations where the requirements are respected but the structure is different; such variations are called spoiled patterns and should also be detected and transformed into acceptable pattern instantiations. This paper first presents an improvement of our design/spoiled pattern detection approach, named MAPeD (Multi-phase Approach for Pattern Discovery). The latter uses an XML information retrieval technique to identify design/spoiled pattern occurrences in a design using, first, static and semantic information and, secondly, dynamic information. This multi-phase detection approach tolerates structural differences between the examined design and the identified design pattern. Furthermore, thanks to the matching information it collects, our identification technique can offer assistance for the improvement of a design. In its second contribution, this paper evaluates MAPeD by comparing its recall and precision rates for five open source systems: JHotDraw, JUnit, JRefactory, MapperXML, QuickUML. The latter were used by other approaches in experimental evaluations. Our evaluation shows that our design pattern identification approach has an average improvement of 9.98% in terms of precision over the best known approach.

Design patterns provide for architecture reuse of reoccurring design problems. They were proposed to improve software quality and accelerate software development. However, the difficulty of their comprehension reinforces the need for a suitable design language. The new design language has to express certain concepts specific to patterns, e.g., their reuse variability and context of applicability, which cannot be expressed with UML. This paper overviews currently proposed representations for design patterns, that try to express pattern specific concepts. It then proposes a UML-based design language that better represents the design patterns. This latter is supported by a CASE toolset that both helps in pattern representation and guides a pattern reuse. The proposed language and toolset are illustrated through the graphical drawing editor JHotDraw, a framework for graphical editors.

Summary form only given. Object-oriented frameworks are recognized as a promising technique for architectural reuse. To guide a framework reuse and help in the traceability of a model, we have proposed an UML profile for framework design, called F-UML. In addition, to provide for precise analysis and reuse validation, we defined a formal semantics for the class diagram of F-UML. In this paper, we complete the formalization of F-UML in object-Z. We, then, show how the formal semantics can be used to analyze both syntactic and semantic/domain specific properties of a framework, and to validate a framework reuse.

Frameworks offer reuse through the generality they have to encompass. This same property, however, often makes a framework design fairly complex, hard to understand and, hence, to reuse. This paper briefly presents the F-UML design. It then focuses on the definition of the formal semantics of F-UML. This latter is defined through a translation of the meta-model of F-UML to Object-Z. The Object-Z semantics allows a designer to prove the syntactic well-formedness of an F-UML design. In addition, it allows the verification of several design properties through a theorem prover.

Frameworks are a promising technology for software design reuse. However, their difficult design may impede their widespread use in software engineering. This paper presents a framework design process for F-UML, an object-oriented design language that offers graphical annotations to guide framework reuse. The F-UML design process is based on a stepwise, bottom-up unification by applying a set of comparison rules on various applications in the framework domain.