Code cloning remains a significant challenge in modern software development, particularly within the Object-Oriented paradigm and advanced methodologies such as the Software Product Line (SPL) approach. In this context, code smells and refactoring can be seen as two sides of the same coin—one representing the symptoms of poor design, and the other offering systematic strategies for improvement. Among the various software quality attributes, maintainability stands out as a critical factor in determining the long-term success of SPL-based systems. However, the presence of cloned code directly impacts this maintainability, making the detection and mitigation of such clones an essential concern. Although multiple quality models exist to assess the relationship between code cloning, refactoring, and maintainability, most lack the granularity to accurately capture the specific effects of code cloning within SPL environments. This research undertakes a systematic literature review to consolidate and analyze findings from existing surveys, with a particular focus on identifying software metrics capable of evaluating the impact of refactoring on SPL maintainability. Refactoring serves as a deliberate means to eliminate code smells, and numerous tools and techniques have been developed to support this process. By synthesizing the current body of knowledge, this study provides a foundation for researchers and practitioners to better understand, select, and apply effective practices and tools to reduce code smells, improve maintainability, and ultimately enhance the overall quality of SPL-based software systems

Flexible process variant binding in information systems with software product line engineering

Refactoring cross-project code duplication in an industrial software product line: A case study from RDW

The integration of Machine Learning (ML) components into modern software systems enhances datadriven decision-making but introduces new challenges for Software Product Line (SPL) engineering. Variability modeling, configuration, and reuse become increasingly complex when adaptive ML components are involved. Although previous studies have addressed variability in traditional SPLs and ML integration in standalone systems, limited work has systematically explored the intersection of these two domains. This paper presents a structured framework that extends SPL engineering to support ML-aware variability management. The framework enables the systematic modeling and configuration of ML components and has been implemented in the VariaMos web tool. A case study demonstrates the framework’s feasibility and applicability, illustrating how it supports the development of adaptive and intelligent product lines.

Manufacturing companies are industrial enterprises that process raw materials and implement Supply Chain Management (SCM). SCM encompasses three stages: material management, planning and control, and production. While these stages are common across manufacturing companies, the workflows and strategies employed vary based on the type of goods produced. For example, one company typically approaches process orders based on requests, whereas the other processes orders based on stock availability. To address these similarities and differences, a software product line engineering (SPLE) approach can be utilized to develop SCM systems. This approach has already been proven effective in other cases, such as developing various product specifications for our Crowdfunding Application (Amanah CS UI) partner. SPLE follows the principle of mass customization, analyzing the commonalities and variabilities of the SCM system to meet diverse company needs. This approach improves the cost optimization and time efficiency in developing various SCM specifications to fulfill the requirements of each company. The development of the SCM system in this study adopts a delta-oriented programming paradigm and Abstract Behavioral Specification programming language. Subsequently, a comparison was made between the development of the SCM system using the SPLE approach and the clone-and-own approach. The research results in an enhanced SCM system developed through the SPLE, establishing it as the primary solution to existing development issues: reusing shared components and adding new custom components. Additionally, it includes an analysis that compares the SPLE approach with the clone-and-own method.

ABSTRACTIn the realm of software product line engineering (SPLE), ensuring the quality of end products is paramount for market success. SPLE promotes systematic software development through reuse by focusing on commonalities and variabilities within a domain to efficiently produce a family of related systems. The quality of a software system depends on its functional properties (FPs)—the functionalities it provides—and its non‐functional properties (NFPs)—the quality attributes it possesses, such as security and performance. NFPs are particularly critical because they directly impact user satisfaction, determine project success, and significantly influence market acceptance. However, in SPLE, despite their recognized importance, NFPs often receive less attention compared to FPs, leading to potential quality risks and increased costs. This paper presents a framework for testing goal‐oriented NFPs in software product lines, addressing this gap. By integrating goal models, the framework supports the systematic capture and validation of NFPs from early development stages. The framework's applicability is illustrated through research‐based case studies in an online bookstore product line, demonstrating its use for systematic NFPs testing at both the domain and application levels. A comparative analysis with an existing technique highlights the framework's unique contributions in addressing NFPs testing within software product lines. Additionally, a preliminary experiment using two widely recognized product line domain examples evaluated the core testing process supported by the framework during the domain engineering phase, focusing on effectiveness, performance efficiency, and time consistency in structured research settings.

ABSTRACT Objectives Cookiecutter is a popular, mature open‐source Python library for automating the creation of customized projects from templates. This kind of scaffolding is useful for enabling reuse, encapsulating expertise, achieve uniformity, and facilitating project creation for a range of languages and domains, including microservices, web applications, and data science. Despite their success, there is a lack of descriptions of general‐purpose project templating tools such as Cookiecutter in the literature. The objective of the paper is to provide a description of Cookiecutter that is useful for researchers and practitioners. Methods Our work is informed by our own use of Cookiecutter in the context of an industrial project. We describe Cookiecutter with the help of four different research questions. The first two relate to how Cookiecutter works (RQ1) and how it is used (RQ2). The latter two are concerned with providing guidance to users of Cookiecutter (RQ3) and identifying challenges that they may face (RQ4). Result Our answer to question RQ1 provides a succinct, high‐level description of the structure of Cookiecutter templates and Cookiecutter's execution semantics. For question RQ2, we provide an analysis of the 100 most popular Cookiecutter templates on GitHub and descriptions of three applications of Cookiecutter in different domains. For question RQ3, we identify quality attributes for Cookiecutter projects together with best practice recommendations. For question RQ4, our discussion of challenges is structured around different lifecycle activities related to the overall management of Cookiecutter templates. The potential for research results in related areas such as software product lines, feature and variability modeling, and model‐driven engineering to help address these challenges is highlighted. Conclusion The paper provides a comprehensive discussion of Cookiecutter, a successful general‐purpose project templating tool with demonstrated industrial use. The discussion covers fundamental and practical aspects of Cookiecutter and thus targets practitioners as well as researchers interested in general‐purpose templating and Cookiecutter in particular.

Tools and Software at the Systems and Software Product Line Conference (SPLC 2022 and 2023)

Software reuse is a cornerstone of modern software engineering, enhancing development efficiency and system adaptability. Software Product Lines (SPL) offer a structured approach to creating software families by leveraging reusable assets within a specific domain. This paper presents a methodology for migrating an open-source project management application to an SPL using the Mobioos Forge platform. Additionally, we extend the application with a new microservice-based module aligned with Algeria's recent regulatory framework (Loi organique 18-15). Our results demonstrate improved reusability and flexibility, supported by feature modeling, variant generation, and a modular architecture. This work highlights the practical benefits of SPL in real-world applications.

Feature models (FMs) play a crucial role in software product lines (SPLs) by representing variability and enabling the generation of diverse product configurations. However, the vast number of possible configurations often makes it challenging to identify the most suitable variant, especially when multiple criteria must be considered. Multi-criteria decision-making (MCDM) methods, such as analytic hierarchy process (AHP), technique for order of preference by similarity to ideal solution (TOPSIS), and VIseKriterijumska Optimizacija I Kompromisno Resenje (“multicriteria optimization and compromise solution”) (VIKOR), are effective for ranking configurations based on user-defined preferences. However, the application of disparate MCDM techniques to the same feature model with identical criteria can yield conflicting rankings, thereby complicating the decision-making process. To address this issue, we propose a novel framework that systematically integrates multiple MCDM methods to prioritise product configurations and provides informed decision support to reconcile ranking discrepancies. The framework automates the prioritisation process and offers a structured approach to explain differences between rankings, enhancing transparency and user confidence in the final selection. The framework’s effectiveness has been validated through real-world case studies, demonstrating its ability to streamline configuration prioritisation and support consistent, preference-driven decision-making in complex SPL environments.

In Software Product Lines (SPLs), localizing buggy feature interactions helps developers identify the root cause of test failures, thereby reducing their workload. This task is challenging because the number of potential interactions grows exponentially with the number of features, resulting in a vast search space, especially for large SPLs. Previous approaches have partially addressed this issue by constructing and examining potential feature interactions based on suspicious feature selections (e.g., those present in failed configurations but not in passed ones). However, these approaches often overlook the causal relationship between buggy feature interaction and test failures, resulting in an excessive search space and high-cost fault localization. To address this, we propose a low-cost Counterfactual Reasoning-Based Fault Localization (CRFL) approach for SPLs, which enhances fault localization efficiency by reducing both the search space and redundant computations. Specifically, CRFL employs counterfactual reasoning to infer suspicious feature selections and utilizes symmetric uncertainty to filter out irrelevant feature interactions. Additionally, CRFL incorporates two findings to prevent the repeated generation and examination of the same feature interactions. We evaluate the performance of our approach using eight publicly available SPL systems. To enable comparisons on larger real-world SPLs, we generate multiple buggy mutants for both BerkeleyDB and TankWar. Experimental results show that our approach reduces the search space by 51%∼73% for small SPLs (with 6∼9 features) and by 71%∼88% for larger SPLs (with 13∼99 features). The average runtime of our approach is approximately 15.6 times faster than that of a state-of-the-art method. Furthermore, when combined with statement-level localization techniques, CRFL can efficiently localize buggy statements, demonstrating its ability to accurately identify buggy feature interactions.

Abstract This paper introduces a novel prioritisation method, the Thematic Hierarchy Process, designed to work with software release cycles in a matrix product development organisation with software product lines and multiple business lines. Three challenges are identified for prioritisation of requirements for software product lines with multiple business lines: scale, complexity and stakeholder discordance. The paper reviews current prioritisation methods and assesses their application to software product lines with multiple business lines with respect to these three challenges, and concludes that none of the existing methods can satisfactorily address all of them. In this paper we define the Thematic Hierarchy Process method, and provide a framework that can be applied by software product managers and researchers to their own software releases and requirements data. The Thematic Hierarchy Process was assessed using requirements data from Company A demonstrating strong alignment with real software release cycles, as shown by the high similarity scores of 0.87 and 0.91 in predicting release contents. Interviews carried out with domain experts to evaluate the Thematic Hierarchy Process to supplement the assessments also showed positive results. We conclude that the Thematic Hierarchy Process can satisfy the prioritisation challenges of scale, complexity and stakeholder discordance with software product lines with multiple business lines.

The Product Line Architecture (PLA) is one of the most important artifacts of a Software Product Line (SPL). PLA design can be formulated as an interactive optimization problem with many conflicting factors. Incorporating Decision Makers’ (DM) preferences during the search process may help the algorithms find more adequate solutions for their profiles. Interactive approaches allow the DM to evaluate solutions, guiding the optimization according to their preferences. However, this brings up human fatigue problems caused by excessive interactions and solutions to evaluate. A common strategy to prevent this problem is limiting the number of interactions and solutions the DM evaluates. Machine Learning (ML) models were also used to learn how to evaluate solutions according to the DM profile and replace them after some interactions. Feature selection performs an essential task as non-relevant and/or redundant features used to train the ML model can reduce the accuracy and comprehensibility of the hypotheses induced by ML algorithms. This study aims to enhance the usage of an ML model in an interactive search-based PLA design approach by addressing two critical challenges: mitigating decision-maker fatigue through feature selection and improving computational efficiency, particularly during testing phases. We applied four selectors, and through results, We managed to reduce 30% of the features and 25% of the time spent on testing, achieving an accuracy of 99%.

The development of learning objects, much like software development, is a creative yet often time-consuming and expensive process. Despite the longstanding SCORM standard, ontologies, and Semantic Web technologies are not widely applied for delivering learning objects. The perceived lack of interoperability among learning systems is commonly argued, but the real barrier to reusability lies in the learning objects themselves. This issue mirrors the software development landscape in 1968, where complexity hindered source code reuse until the arrival of Software Product Lines (SPL). These systems share a multitude of common features, yet they also incorporate some distinctive variable aspects. Thus, the transposition - Educational content product lines may be a new idea, but their potential application is facing an obstacle - producing shareable and reusable learning objects. In this paper, we address this obstacle by an approach establishing interrelations between the tasks defined within the sprint backlog and the solution found based on the task itself and the artifacts bound to it. This paper introduces a relevant analogy of Learning Object creation with practices from Software Engineering and also demonstrates the possibility of knowledge interrelation through a proof of concept, formal definition using algebraic specification and an experiment.

A structural taxonomy for lifted software product line analyses

This article proposes a novel framework for the development of product lines for web systems. Software product line engineering is a well-established reuse mechanism to aid development of related software products with a large degree of variability. Web systems, which exhibit high variability (different capabilities in each deployment) and commonality (similar user interfaces and functionalities), are very well suited for this approach. At the same time, web systems are amenable to model-driven software engineering, because they typically encompass loosely coupled and fixed functionality, which makes code generation feasible. In consequence, a model-driven software product line engineering (MDSPLE) approach to develop web systems is natural and in fact was variously suggested. However, all existing MDSPLE proposals either cover mainly the problem space. If they address the solution space at all, the technology is not variability-aware. In consequence, they lack reusability at the code level and feature-granular traceability. Our contribution is an MDSPLE-based framework that permits seamless end-to-end development of web systems. The framework is fully implemented and evaluated with realistic web systems in actual use. Our solution consists of two parts: A variability-aware extension of UML diagrams in the problem space and a feature-oriented behavioral modeling language in the solution space. Both languages have been carefully chosen (and extended) to provide a tightly fitting technology match and are based on delta-oriented programming.

EHHO-EL: a hybrid method for software defect detection in software product lines using extended Harris hawks optimization and ensemble learning

Automated program repair for variability bugs in software product line systems

Software Product Lines (SPLs) improve time-to-market, enhance software quality, and reduce maintenance costs. Current SPL reengineering practices are largely manual and require domain knowledge. Thus, adopting and, to a lesser extent, maintaining SPLs are expensive tasks, preventing many companies from enjoying their benefits. To address these challenges, we introduce Foundry , an approach utilising software transplantation to reduce the manual effort of SPL adoption and maintenance. Foundry enables integrating features across different codebases, even codebases that are unaware that they are contributing features to a software product line. Each product produced by Foundry is pure code, without variability annotation, unlike feature flags, which eases variability management and reduces code bloat. We realise Foundry in prodScalpel , a tool that transplants multiple organs (i.e., a set of interesting features) from donor systems into an emergent product line for codebases written in C. Given tests and lightweight annotations identifying features and implantation points, prodScalpel automates feature extraction and integration. To evaluate its effectiveness, our evaluation compares feature transplantation using prodScalpel to the current state of practice: on our dataset, prodScalpel ’s use speeds up feature migration by an average of 4.8 times when compared to current practice.

This research presents an innovative methodological framework for software development that integrates Artificial Intelligence (AI) techniques, Software Product Lines (SPL), and Lehman’s [24] aging factors. The main objective is to improve the efficiency and adaptability of design processes for residential spaces through intelligent automation. This framework covers the entire software development life cycle, utilizing AI algorithms to optimize design and respond to the evolving needs of users while maximizing resource usage. A case study on a connected home concretely illustrates the application of this framework, demonstrating its effectiveness in creating dynamic and personalized designs. Furthermore, it addresses the issue of software sustainability by incorporating aging laws throughout their life cycle, an aspect often overlooked in existing solutions. By combining product line engineering and AI techniques, this framework offers a structured approach that promotes both sustainability and personalization. It has the potential to transform practices across various sectors, such as healthcare, finance, and education, while fostering a culture of sustainable innovation. However, its effectiveness also depends on the skills and experience of development teams, highlighting the importance of considering human factors in its application