Context: Many Fault Localization (FL) approaches are designed to locate a single fault, but multiple faults typically exist in large programs. Multi-fault localization approaches at the statement level usually rely on Spectrum-Based Fault Localization (SBFL) without considering Information Retrieval-Based Fault Localization (IRFL). Objective: In this paper, we propose , a multi-fault localization approach that leverages an evolutionary algorithm to locate the code fragment that may be the cause of failure. The evolutionary algorithm can help to efficiently explore the sheer number of candidate code fragments, whereas the fitness function of the evolutionary algorithm combines Ochiai (SBFL) and LDA (IRFL) to assess the suspiciousness of each candidate code fragment. Method: We evaluate using the Defects4J benchmark, and we compare its results against four baselines: SBFL (Ochiai), IRFL (LDA and Blues), and hybrid (Ochiai and Blues). The comparison involves a statistical analysis to provide quantitative evidence of the impact of the results. Results: The results show that significantly outperforms the baselines by a large effect size. Specifically, our approach outperforms the best performing baseline by 51.7%, 19.6%, 11.5% and 11.5% for hit@1, 3, 5 and 10, respectively. Conclusion: Our work provides a new direction for the multi-fault localization of statements using an evolutionary algorithm and combining Ochiai and LDA as fitness function, which is valuable for the automated program repair community since FL directly impacts the accuracy of software fixes.

Code smells are indicators of potential design issues in source code that can affect the overall software quality. Detecting these smells has been the focus of extensive research efforts using both traditional metric-based techniques and, more recently, deep learning models. Among these, Large Language Models (LLMs) have emerged as powerful tools due to their strong capabilities in code understanding and classification tasks. LLMs such as CodeT5 and CodeBERT were employed to detect various smells with promising results. However the integration of these models into software engineering workflows remains challenging as current approaches often lack traceability, modularity, and reusability, making it difficult to track results, compare configurations, or systematically explore model variations. To address these limitations, we introduce in this paper DetectorsForge, a Software Product Line (SPL) that enables the systematic configuration, customization, and execution of LLM-based code smell detectors. DetectorsForge unifies models, datasets, transfer learning techniques, and evaluation methods to adapt pre-trained models to new downstream tasks. These components are integrated within a reusable architecture that supports the automated derivation of code smell detection variants. Experimental results demonstrate the applicability of our approach for generating various code smell detectors.

Preprocessor directives such as #ifdef have historically been the predominant mechanism for managing variability in legacy$C / C++$codebases. While they offer a simple way to include or exclude code at compilation time, they lack explicit variability representation and make it difficult to reason about features beyond conditional inclusion. Over time, these directives tend to become scattered, redundant, and obsolete resulting in tangled and rigid implementations that hinder maintenance, reuse, and long-term evolution. With the growing maturity of Software Product Line Engineering (SPLE) and the emergence of industrial tools such as Mobioos Forge (MF), it is now possible to rethink the variability management in legacy systems. MF enables the specification of variability through feature models, the building of feature-to-code mappings, and the static derivation of variants without relying on the compiler. These capabilities pave the way for modernizing configurable codebases by making variability explicit, analyzable, and maintainable. In this paper, we present an integrated toolchain for the automated recovery of Software Product Lines from legacy C/C++ systems. Our approach identifies features and their interactions, synthesizes a hierarchical feature model, and generates traceability links to locate feature-specific code fragments. Built as an extension to MF, our approach can also leverages its static derivation engine to safely remove obsolete features and generate concrete product variants. We validate our approach on large-scale, real-world open-source systems, including Chromium, which contains over$\mathbf{2 5 0 0}$distinct features. The results demonstrate the effectiveness of our method in revealing hidden variability structures, enabling safe variant generation, and supporting the modernization of legacy configurable systems through SPLE principles.

Assessing code quality is crucial for effective software maintenance and evolution. Traditional tools like SonarQube offer valuable insights at the application level but lack the granularity needed for detailed, feature-specific analysis. This paper emphasizes the importance of feature-oriented code quality analysis, often overlooked by mainstream tools due to the challenge of correlating high-level feature descriptions with low-level code implementations. To tackle this issue, we leverage existing feature location techniques to introduce a novel approach enabling granular analysis tailored to specific application features. We discuss the motivations for this approach, highlighting its potential to improve precision in enhancement and maintenance strategies. Additionally, this paper introduces a tool-based approach known as InsightMapper. We also present a study demonstrating the benefits of this method through the analysis of two case studies, featuring a recognized benchmark in the feature location domain.

The adoption of Software Product Lines in the industry remains a major challenge. This paper presents an experience report focused on the application of a novel tool-based approach called Mobioos Forge. We introduce the vision and operational activities of Mobioos Forge, emphasizing its significance through an examination of the complex process of migrating the ArgoUML application - an open-source codebase exceeding 400KLOCs. We highlight the achieved feature model and detail the feature-to-source code mapping. Additionally, we explain the derivation process used to generate the source code for multiple variants. We discuss the time and effort expended on this migration, showcasing that, even with no prior familiarity with ArgoUML, it took less than 11 hours to successfully migrate the entire application into an SPL.

The problem of configuring a variability model is widespread in many different domains. Renault has developed its technology internally to model vehicle diversity. This technology relies on the approach known as knowledge compilation to explore the configurations space. However, the growing variability and complexity of the vehicles’ range hardens the space representation problem and may impact performance requirements. This paper tackles these issues by exploiting symmetries that represent isomorphic parts in the configuration space. The extensive experiments we conducted on datasets from Renault show our approach’s robustness and effectiveness: the achieved gain is a reduction of 52.13% in space representation and 49.81% in processing time on average.

In the combination of Model-Driven Engineering (MDE) and Search-Based Software Engineering (SBSE), genetic operations are one of the key ingredients. Our work proposes a novel adaptation of automatic query reformulations as genetic operations that leverage the latent semantics of software models (the cornerstone artefact of MDE). We analyze the impact of these reformulation operations in a real-world industrial case study of feature location in models. As baselines, we use: 1) the widespread single-point crossover plus random mutation; and 2) mask crossover plus random mutation, which is the best performer for feature location in models. We also perform a statistical analysis to provide quantitative evidence of the impact of the results and to show that this impact is significant. Our reformulation operations improve the results of the best baseline by 37.73 percent in recall and 14.08 percent in precision. These results are relevant for the task of feature location in models (one of the main activities performed during software maintenance and evolution). Furthermore, given that the only requirement to apply our approach is term availability in models, our work opens a new research direction to improve more tasks in MDE such as bug location or requirements traceability.

Code review is an important part of the development of any software project. Recently, many open source projects have begun practicing lightweight and tool-based code review (a.k.a modern code review) to make the process simpler and more efficient. However, those practices still require reviewers, of which there may not be sufficiently many to ensure timely decisions. In this paper, we propose a recommender-based approach to be used by open-source projects to increase the number of reviewers from among the appropriate developers. We first motivate our approach by an exploratory study of nine projects hosted on GitHub and Gerrit. Secondly, we build the recommender system itself, which, given a code change, initially searches for relevant reviewers based on similarities between the reviewing history and the files affected by the change, and then augments this set with developers who have a similar development history as these reviewers but have little or no relevant reviewing experience. To make these recommendations, we rely on collaborative filtering, and more precisely, on matrix factorization. Our evaluation shows that all nine projects could benefit from our system by using it both to get recommendations of previous reviewers and to expand their number from among the appropriate developers.

Abstract Handling large-scale software variability is still a challenge for many organizations. After decades of research on variability management concepts, many industrial organizations have introduced techniques known from research, but still lament that pure textbook approaches are not applicable or efficient. For instance, software product line engineering—an approach to systematically develop portfolios of products—is difficult to adopt given the high upfront investments; and even when adopted, organizations are challenged by evolving their complex product lines. Consequently, the research community now mainly focuses on re-engineering and evolution techniques for product lines; yet, understanding the current state of adoption and the industrial challenges for organizations is necessary to conceive effective techniques. In this multiple-case study, we analyze the current adoption of variability management techniques in twelve medium- to large-scale industrial cases in domains such as automotive, aerospace or railway systems. We identify the current state of variability management, emphasizing the techniques and concepts they adopted. We elicit the needs and challenges expressed for these cases, triangulated with results from a literature review. We believe our results help to understand the current state of adoption and shed light on gaps to address in industrial practice.

Software developers rely on the clone-and-own approach to rapidly develop software product variants (PVs) that meet variability in market needs. To improve the comprehension of how PVs are evolved and varied, we analyze the clone-and-own practices applied by developers of these PVs. We perform an empirical study on 75 android families to gain insights about observable phenomena related to the commonality and variability between the source code of PVs of these families. In particular, we study three research questions to identify the commonality and variability related to the organization of source code files, cloning Java methods, and configuration parameters of AndroidManifest.xml files. The results show that cloning packages, Java files and Java methods is a common practice used by developers of all android families. Maintainers should put efforts for managing the diverse implementations (bodies) of the modified cloned methods and it is essential to consider the commonality and variability of configuration parameters.

A large component and service-based software system exists in different forms, as different variants targeting different business needs and users. This kind of systems is provided as a set of "independent" products and not as a "single whole". Developers use ad hoc mechanisms to manage variability. However, for deriving new product variants that are built upon existing ones, the presence of a single model describing the architecture of the whole system with an explicit specification of commonality and variability is of great interest. Indeed, this enables them to see the invariant part of the whole, on top of which new functionality can be built, in addition to the different options they can use. We investigate in this work the use of software product line reverse engineering approaches, and in particular the framework named But4Reuse, for recovering an architecture model that enables us to build a Software Architecture Product Line (SAPL), from a set of software variants. We propose a generic process for recovering an architecture model of such a product line. We have instantiated this process for the OSGi Java framework and experimented it for building the architecture model of Eclipse IDE SPL. The results of this experimentation showed that this process can effectively reconstruct such an architecture model.

Transforming a clone-and-own (i.e., new product variants are created by copying and modifying existing artifacts) code structure and development process to a Software Product Line Engineering (PLE) approach is a tedious and error-prone task. Holistic tool support for such a process is highly desirable, especially to lower efforts and to speed up the transformation. Unfortunately, such a holistic toolchain for reverse engineering of variability, supporting variant-centric and platform-centric extraction approaches is not available. In this paper, we present a toolchain covering the first steps for moving a clone-and-own product development to a PLE approach. We validate the first prototype of the toolchain on a case study consisting of industrial firmware for smart motor controllers and we show that even this early prototype reduces time and effort for moving to a configurable platform approach in the sense of PLE.

This paper presents a Software Product Line (SPL) extraction approach to handle legacy software systems running on the Java Virtual Machine (JVM), for which the source code is unavailable, and factor in all input programming languages for the JVM. The approach extracts from the bytecode of a collection of software variants created using the Clone-And-Own approach a full SPL with its feature model. We provide a full implementation and integration in the BUT4Reuse framework. An early experiment was carried out on the ArgoUML case study and preliminary results are discussed.

Feature location is a traceability recovery activity to identify the implementation elements associated to a characteristic of a system. Besides its relevance for software maintenance of a single system, feature location in a collection of systems received a lot of attention as a first step to re-engineer system variants (created through clone-and-own) into a Software Product Line (SPL). In this context, the objective is to unambiguously identify the boundaries of a feature inside a family of systems to later create reusable assets from these implementation elements. Among all the case studies in the SPL literature, variants derived from ArgoUML SPL stands out as the most used one. However, the use of different settings, or the omission of relevant information (e.g., the exact configurations of the variants or the way the metrics are calculated), makes it difficult to reproduce or benchmark the different feature location techniques even if the same ArgoUML SPL is used. With the objective to foster the research area on feature location, we provide a set of common scenarios using ArgoUML SPL and a set of utils to obtain metrics based on the results of existing and novel feature location techniques.

The engineering of a Software Product Line (SPL), either by creating it from scratch or through the re-engineering of existing variants, it uses to be a project that spans several years with a high investment. It is often hard to analyse and quantify this investment, especially in the context of extractive SPL adoption when the related software variants are independently created by different developers following different system architectures and implementation conventions. This paper reports an experience on the creation of an SPL by re-engineering system variants implemented around an educational game called Robocode. The objective of this game is to program a bot (a battle tank) that battles against the bots of other developers. The world-wide Robocode community creates and maintains a large base of knowledge and implementations that are mainly organized in terms of features, although not presented as an SPL. Therefore, a group of master students analysed this variability-rich domain and extracted a Robocode SPL. We present the results of such extraction augmented with an analysis and a quantification regarding the spent time and effort. We believe that the results and the a-posteriori analysis can provide insights on global challenges on SPL adoption. We also provide all the elements to SPL educators to reproduce the teaching activity, and we make available this SPL to be used for any research purpose.

Software Product Line (SPL) migration remains a challenging endeavour. From organizational issues to purely technical challenges, there is a wide range of barriers that complicates SPL adoption. The workshop REverse Variability Engineering (REVE) aims to foster research about making the most of the two main inputs for SPL migration: 1) domain knowledge and 2) legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create or extract the reusable software components. Legacy assets can be, for instance, similar product variants (e.g., requirements, models, source code) that were implemented using ad-hoc reuse techniques such as clone-and-own. More generally, the workshop attracts researchers and practitioners contributing to processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.

This year at SPLC we present a teaching and research project where a group of master students analysed a variability-rich domain and extracted an SPL (The Robocode SPL). We present the results of such extraction augmented with an analysis and a quantification regarding the time and effort spent. The research objective was to get and share data about an end-to-end SPL extraction which is usually unavailable in industrial cases because of their large size, complexity, and duration. We provide all the material to replicate, reproduce or extend the case study so it can be easily reused for teaching by anyone in our community. However, we were asking ourselves how can we leverage such case study for teaching to pursue research objectives. In this position paper, we aim to outline our initial ideas that we want to enrich with the others' viewpoints during SPLTea. Towards planning the settings of future teaching projects around this Robocode SPL case study, which can be the timely research objectives that we can identify? Can we involve others in planning this project in their institutions to get further relevant results?

Software processes, as software products, are variable across projects and thus a one-size-fits-all approach does not work out for development processes. We propose Meduse, an approach for tailoring development processes according to project needs. Such an approach, which is based on software product line and method engineering techniques, takes into account processes similarities (i.e. commonalities) and differences (i.e. variabilities), as well as reusable process fragments. Having processes tailored on demand according to the project needs shall reduce project risks, rise best practices adoption by the development team, support project planning and budget managing, among other benefits.

The myriads of smart phones around the globe gave rise to a vast proliferation of mobile applications. These applications target an increasing number of user profiles and tasks. In this context, Android is a leading technology for their development and on-line markets are the main means for their distribution. In this paper we motivate, from two perspectives, the mining of these markets with the objective to identify families of apps variants in the wild. The first perspective is related to research activities where building realistic case studies for evaluating extractive SPL adoption techniques are needed. The second is related to a large-scale, world-wide and time-aware study of reuse practice in an industry which is now flourishing among all others within the software engineering community. This study is relevant to assess potential for SPLE practices adoption. We present initial implementations of the mining process and we discuss analyses of variant families.

From organizational issues to purely technical challenges, there is a wide range of barriers that complicates Software Product Line (SPL) adoption. This workshop aims to foster research about making the most of two main inputs for SPL migration: 1) domain knowledge and 2) existing legacy assets. Domain knowledge, usually implicit and spread across an organization, is key to define the SPL scope and to validate the variability model and its semantics. At the technical level, domain expertise is also needed to create reusable software components. Regarding legacy assets, they use to be similar product variants (e.g. requirements, models, source code etc.) that were implemented using ad-hoc reuse techniques such as clone-and-own. These assets can be leveraged in extractive SPL adoption processes. The workshop REverse Variability Engineering (REVE) attracts researchers and practitioners contributing processes, techniques, tools, or empirical studies related to the automatic, semi-automatic or manual extraction or refinement of SPL assets.

Reengineering a Software Product Line from legacy variants remains a challenging endeavour. Among various challenges, it is a complex task to retrieve enough information for inferring the variability from experts' domain knowledge and from the semantics of software elements. We propose the VariClouds process that can be leveraged by domain experts to understand the semantics behind the different blocks identified during software variants analysis. VariClouds is based on interactive word cloud visualisations providing name suggestions for these blocks using tf-idf as weighting factor. We evaluate our approach by assessing its added-value to several previous works in the literature where no tool support was provided to domain experts to characterise features from software blocks.

We address the problem of automating 1) the analysis of existing similar model variants and 2) migrating them into a software product line. Our approach, named MoVaPL, considers the identification of variability and commonality in model variants, as well as the extraction of a CVL-compliant Model-based Software Product Line (MSPL) from the features identified on these variants. MoVaPL builds on a generic representation of models making it suitable to any MOF-based models. We apply our approach on variants of the open source ArgoUML UML modeling tool as well as on variants of an In-flight Entertainment System. Evaluation with these large and complex case studies contributed to show how our feature identification with structural constraints discovery and the MSPL generation process are implemented to make the approach valid (i.e., the extracted software product line can be used to regenerate all variants considered) and sound (i.e., derived variants which did not exist are at least structurally valid).

Variability management of a product family is the core aspect of Software Product Line Engineering. The adoption of this mature approach requires a high upfront investment before being able to automatically generate product instances based on customer requirements. However, this adoption costs and risks could be reduced with an incremental approach, which mines existing assets and then transitions to full product line engineering. Those existing assets can be for instance similar product variants that were implemented using ad-hoc reuse techniques such as clone-and-own. Hence, there is a great need of bottom-up approaches that extract variability from the artifacts (across all the life cycle) of the legacy product variants and manage the consolidated variability. The REVE workshop series aims to bring together the Reengineering and Software Product Line Engineering communities to address this gap.

Although Software Product Lines are recurrently praised as an efficient paradigm for systematic reuse, practical adoption remains challenging. For bottom-up Software Product Line adoption, where a set of artefact variants already exists, practitioners lack end-to-end support for chaining (1) feature identification, (2) feature location, (3) feature constraints discovery, as well as (4) reengineering approaches. This challenge can be overcome if there exists a set of principles for building a framework to integrate various algorithms and to support different artefact types. In this paper, we propose the principles of such a framework and we provide insights on how it can be extended with adapters, algorithms and visualisations enabling their use in different scenarios. We describe its realization in BUT4Reuse (Bottom--Up Technologies for Reuse) and we assess its generic and extensible properties by implementing a variety of extensions. We further empirically assess the complexity of integration by reproducing case studies from the literature. Finally, we present an experiment where users realize a bottom-up Software Product Line adoption building on the case study of Eclipse variants.

Behavior Model Inference techniques aim at mining behavior models from execution traces. While most of approaches usually ground on local similarities in traces, recent work, referred to as behavior mining with temporal steering, propose to include long term dependencies in the mining process. Such dependencies correspond to temporal implications between events in execution traces, whose consideration allows to ensure a better consistency of the extracted model. Nevertheless, the existing approaches are usually limited by their high computational complexity and the approximations to reduce the cost of temporal rules checking. This paper revisits behavior mining with temporal steering by defining an efficient algorithm that performs an exact consideration of the observed dependencies: in our experiments, greatly reduced processing times (from exponential to quasi-linear) for exact mining with temporal steering have been observed. Furthermore, beyond highlighting the great benefits of considering temporal dependencies, this paper also proposes new key extensions to the existing work that allow to include more complex dependencies in the mining process. Intensive evaluation finally demonstrates the great performances of the proposed approach.

Variability management of a product family is the core aspect of Software Product Line Engineering. The adoption of this mature approach requires a high upfront investment before being able to automatically generate product instances based on customer requirements. However, this adoption costs and risks could be reduced with an incremental approach, which mines existing assets and then transitions to full product line engineering. Those existing assets can be for instance similar product variants that were implemented using ad-hoc reuse techniques such as clone-and-own. Bottom-up approaches to automatically extract variability management related artifacts could be proposed, applied, validated and improved in this domain therefore the REVE workshop aims to fill the gap between the Reengineering and Software Product Line Engineering communities.

Software Product Line Engineering is a mature approach enabling the derivation of product variants by assembling reusable assets. In this context, domain experts widely use Feature Models as the most accepted formalism for capturing commonality and variability in terms of features. Feature Models also describe the constraints in feature combinations. In industrial settings, domain experts often deal with Software Product Lines with high numbers of features and constraints. Furthermore, the set of features are often regrouped in different subsets that are overseen by different stakeholders in the process. Consequently, the management of the complexity of large Feature Models becomes challenging. In this paper we propose a dedicated interactive visualisation paradigm to help domain experts and stakeholders to manage the challenges in maintaining the constraints among features. We build Feature Relations Graphs (Frogs) by mining existing product configurations. For each feature, we are able to display a Frog which shows the impact, in terms of constraints, of the considered feature on all the other features. The objective is to help domain experts to 1) obtain a better understanding of feature constraints, 2) potentially refine the existing feature model by uncovering and formalizing missing constraints and 3) serve as a recommendation system, during the configuration of a new product, based on the tendencies found in existing configurations. The paper illustrates the visualisation paradigm with the industrial case study of Renault's Electric Parking System Software Product Line.

Reverse engineering of behavior models has received a lot of attention over the last few years. However, no standard benchmark exists for the comparison and analysis of published miners. Evaluation is usually performed on few case studies, which fails to demonstrate effectiveness in a broad context. This paper proposes a general, approach-independent, platform for the intensive evaluation of behavior miners. Its goals are essentially: provide a benchmark mechanism for reverse engineering; allow analysis of miners w.r.t. a class of programs and/or behaviors; help users in choosing the best suited approach for their objective.

The reverse engineering of behavioral models consists in extracting high-level models that help understand the behavior of existing software systems. In the context of reverse engineering of sequence diagrams, most approaches strongly depend on the static analysis and instrumentation of the source code to produce correct diagrams that take into account control flow structures such as alternative blocks ("if"s) and repeated blocks ("loop"s). This approach is not possible with systems for which no source code is available anymore (e.g. some legacy systems). In this paper, we propose an approach for the reverse engineering of sequence diagrams from the analysis of execution traces produced dynamically by an object-oriented application. Our approach is fully based on dynamic analysis and reuses the k-tail merging algorithm to produce a Labeled Transition System (LTS) that merges the collected traces. This LTS is then translated into a sequence diagram which contains alternatives and loops. A prototype of this approach has been tested with a real world application that has been developed independently from the present work. Our results show that this approach can produce sequence diagrams in reasonable time and suggest that these diagrams are helpful in understanding the behavior of the underlying application.

In this article paper entitled "From Play-In Scenarios to Code: An Achievable Dream",David Harel presented a development schema that makes it possible to go from high-level user-friendly requirements to a full system model, and from there to the final implementation. Even if Harel's schema represents a real contribution to filing the gap between user requirements and final implementations, there is few work on its feasibility and none within UML2.This paper addresses this lack. First we use UML2 sequence diagram as a formalism for requirement specification. Then an approach that synthesizes state machines from UML2 sequence diagrams is presented. From the obtained state machines, we implement a transformation to code. The AIBO platform (one of several typesof robotic pets designed and manufactured by Sony) is used as a case study toillustrate our implementation.

The idea of synthesizing statecharts out of a collection of scenarios has received a lot of attention in recent years. However due to the poor expressive power of first generation scenario languages, including UML 1.x sequence diagrams, the proposed solutions often use ad hoc tricks and suffer from many shortcomings. The recent adoption in UML 2.0 of a richer scenario language, including interesting composition operators, now makes it possible to revisit the problem of statechart synthesis with a radically new approach. Inspired by the way UML 2.0 sequence diagrams can be algebraically composed, we first define an algebraic framework for composing statecharts. Then we show how to leverage the algebraic structure of UML 2.0 sequence diagrams to get a direct algorithm for synthesizing a composition of statecharts out of them. The synthesized statecharts exhibit interesting properties that make them particularly useful as a basis for the detailed design process. Beyond offering a systematic and semantically well founded method, another interest of our approach lies in its flexibility: the modification or replacement of a given scenario has a limited impact on the synthesis process, thus fostering a better traceability between the requirements and the detailed design.