Software Product Families Research Articles

Software product line testing: a systematic literature review

A Software Product Line (SPL) is a software development paradigm in which a family of software products shares a set of core assets. Testing has a vital role in both single-system development and SPL development in identifying potential faults by examining the behavior of a product or products, but it is especially challenging in SPL. There have been many research contributions in the SPL testing field; therefore, assessing the current state of research and practice is necessary to understand the progress in testing practices and to identify the gap between required techniques and existing approaches. This paper aims to survey existing research on SPL testing to provide researchers and practitioners with up-to-date evidence and issues that enable further development of the field. To this end, we conducted a Systematic Literature Review (SLR) with seven research questions in which we identified and analyzed 118 studies dating from 2003 to 2022. The results indicate that the literature proposes many techniques for specific aspects (e.g., controlling cost/effort in SPL testing); however, other elements (e.g., regression testing and non-functional testing) still need to be covered by existing research. Furthermore, most approaches are evaluated by only one empirical method, most of which are academic evaluations. This may jeopardize the adoption of approaches in industry. The results of this study can help identify gaps in SPL testing since specific points of SPL Engineering still need to be addressed entirely.

Local features: Enhancing variability modeling in software product lines

Context and motivation:Software Product Lines (SPL) enable the creation of software product families with shared core components using feature models to model variability. Choosing features from a feature model to generate a product may not be sufficient in certain situations because the application engineer may need to be able to decide on configuration time the system’s elements to which a certain feature will be applied. Therefore, there is a need to select which features have to be included in the product but also to which of its elements they have to be applied. Objective:We introduce local features that are selectively applied to specific parts of the system during product configuration. Results:We formalize local features using multimodels to establish relationships between local features and other elements of the system models. The paper includes examples illustrating the motivation for local features, a formal definition, and a domain-specific language for specification and implementation. Finally, we present a case study in a real scenario that shows how the concept of local features allowed us to define the variability of a complex system. The examples and the application case show that the proposal achieves higher customization levels at the application engineering phase.

Evaluating the influence of scope on feature location

Feature Location (FL) is a widespread technique that is used to maintain and evolve a software product. FL is also helpful in reengineering a family of software products into a Software Product Line (SPL). Despite the popularity of FL, there is no study that evaluates the influence of scope (single product or product family) when engineers perform FL.

Properties of a Feature in Code-Assets: An Exploratory Study

Software product line engineering is a paradigm for developing a family of software products from a repository of reusable assets rather than developing each individual product from scratch. In featureoriented software product line engineering, the common and the variable characteristics of the products are expressed in terms of features. Using software product line engineering approach, software products are produced en masse by means of two engineering phases: (i) Domain Engineering and, (ii) Application Engineering. At the domain engineering phase, reusable assets are developed with variation points where variant features may be bound for each of the diverse products. At the application engineering phase, individual and customized products are developed from the reusable assets. Ideally, the reusable assets should be adaptable with less effort to support additional variations (features) that were not planned beforehand in order to increase the usage context of SPL as a result of expanding markets or when a new usage context of software product line emerges. This paper presents an exploration research to investigate the properties of features, in the code-asset implemented using Object-Oriented Programming Style. In the exploration, we observed that program elements of disparate features formed unions as well as intersections that may affect modifiability of the code-assets. The implication of this research to practice is that an unstable product line and with the tendency of emerging variations should aim for techniques that limit the number of intersections between program elements of different features. Similarly, the implication of the observation to research is that there should be subsequent investigations using multiple case studies in different software domains and programming styles to improve the understanding of the findings.

A product quality impacts of a mobile software product line: an empirical study

BackgroundThe software product lines (SPL) enable development teams to fully address a systematic reuse of shared assets to deliver a family of similar software products. Mobile applications are an obvious candidate for employing an SPL approach. This paper presents our research outcomes, based on empirical data from an industry-level development project. Two development teams were confronted with the same functionalities set to be delivered through a family of native mobile applications for Android and iOS.MethodsEmpirical data was gathered before, during and after a year of full-time development. The data demonstrate the impact of a SPL approach by comparing the SPL and non-SPL multiple edition development. One family of products (Android apps) was developed using an SPL approach, while another (iOS apps), functionally the same, was developed without employing an SPL approach. The project generated a volume of raw and aggregated empirical data to support our research questions.ResultsThe paper reports a positive impact of an SPL approach on product quality (internal and external) and feature output per week. As data shows, it also increases the delivery of functionalities (240% in 6 more editions), while investing the same amount of effort needed for a single-edition development. As a result of system-supported separation of development and production code, developers had a high confidence in further development. On the other hand, the second team delivered less new functionalities, only two new application editions, and lower software quality than the team that manages multi-edition development by employing an SPL approach.

Design and Realisation of Reusable Artefacts for Internal Supply Chain Management in Manufacturing Company

Maintaining many similar software products with huge similarities and some variations have been studied is Software Product Line Engineering (SPLE). Traditional software methodology lacks the notions to model and maintain those variability and commonality in all phases of standard known software methodology (e.g. from requirement phase up to the testing phase). This paper shows a proposed software methodology based on SPLE to ease the development and maintainability of similar software product. The paper focuses on the design and realizes the reusable artefacts to generate a family of software products systematically with case study example of Supply Chain Management in Manufacturing. This methodology utilized the commonly known UML diagram with the use of UML Profile of Delta Programming and some tools of code generator.

Anomaly analyses for feature-model evolution

Software Product Lines (SPLs) are a common technique to capture families of software products in terms of commonalities and variabilities. On a conceptual level, functionality of an SPL is modeled in terms of features in Feature Models (FMs). As other software systems, SPLs and their FMs are subject to evolution that may lead to the introduction of anomalies (e.g., non-selectable features). To fix such anomalies, developers need to understand the cause for them. However, for large evolution histories and large SPLs, explanations may become very long and, as a consequence, hard to understand. In this paper, we present a method for anomaly detection and explanation that, by encoding the entire evolution history, identifies the evolution step of anomaly introduction and explains which of the performed evolution operations lead to it. In our evaluation, we show that our method significantly reduces the complexity of generated explanations.

An Action Research for Improving the Sustainability Assessment Framework Instruments

In the last years, software engineering researchers have defined sustainability as a quality requirement of software, but not enough effort has been devoted to develop new methods/techniques to support the analysis and assessment of software sustainability. In this study, we present the Sustainability Assessment Framework (SAF) that consists of two instruments: the software sustainability–quality model, and the architectural decision map. Then, we use participatory and technical action research in close collaboration with the software industry to validate the SAF regarding its applicability in specific cases. The unit of analysis of our study is a family of software products (Geographic Information System- and Mobile-based Workforce Management Systems) that aim to address sustainability goals (e.g., efficient collection of dead animals to mitigate social and environmental sustainability risks). The results show that the sustainability–quality model integrated with the architectural decision maps can be used to identify sustainability–quality requirements as design concerns because most of its quality attributes (QAs) have been either addressed in the software project or acknowledged as relevant (i.e., creating awareness on the relevance of the multidimensional sustainability nature of certain QAs). Moreover, the action–research method has been helpful to enrich the sustainability–quality model, by identifying missing QAs (e.g., regulation compliance, data privacy). Finally, the architectural decision maps have been found as useful to guide software architects/designers in their decision-making process.

Полимасштабный анализ миграционных процессов на юге России с помощью средств геоинформационного мониторинга

The article considers the possibilities of using geoinformation systems for monitoring migration processes at different territorial levels. The concept of development and functioning of the system of geoinformation monitoring of migration processes in Russia is proposed. This system makes it possible to obtain, update and analyze information, provide process modeling, and develop effective management solutions. The geoinformation monitoring system is implemented on the basis of the Microsoft SQL Server relational database management system and the ESRI АгсGIS family of software products and consists of five key components: hardware, software, data, performers, and methods. The study of modern migration processes at several territorial levels — from macro-regional to local-was carried out using the geo-information monitoring system. At the macro-regional level (for example, in the South of Russia), there is a differentiation of regions by the level of migration growth and the nature of migration processes. At the regional level of monitoring, the features of internal migration processes in the Stavropol territory are considered. The migration loss zone in the province covers almost all rural areas. Migration growth of the population is typical only for large cities and their suburban areas. At the local settlement level, the geo-information monitoring system makes it possible to study such characteristics of migration processes as the ethnic and social composition of migrants, the distribution of migrants by localities, and migration links between different territories.

Validation of RP-SPF Framework: A Systematic Method for Requirements Reuse in Software Product Lines

Reuse of requirements is crucial activity in software development especially across software product line engineering (SPLE), which involves two main processes known as domain engineering and application engineering. With these two processes SPLE enables systematic reuse of requirements through proper planning and development. This paper presents methodology and result of survey of experts for validating a proposed systematic requirement reuse approach named requirements pattern for software product families (RP-SPF) framework. During the survey, 14 experts in requirements engineering (RE), SPLE and software development responded and gave their opinions on RP-SPF framework. The result of the survey shows that RP-SPF approach is suitable and can effectively improve requirements engineering activities of SPLE.

Product line architecture recovery with outlier filtering in software families: the Apo-Games case study

Software product line (SPL) approach has been widely adopted to achieve systematic reuse in families of software products. Despite its benefits, developing an SPL from scratch requires high up-front investment. Because of that, organizations commonly create product variants with opportunistic reuse approaches (e.g., copy-and-paste or clone-and-own). However, maintenance and evolution of a large number of product variants is a challenging task. In this context, a family of products developed opportunistically is a good starting point to adopt SPLs, known as extractive approach for SPL adoption. One of the initial phases of the extractive approach is the recovery and definition of a product line architecture (PLA) based on existing software variants, to support variant derivation and also to allow the customization according to customers’ needs. The problem of defining a PLA from existing system variants is that some variants can become highly unrelated to their predecessors, known as outlier variants. The inclusion of outlier variants in the PLA recovery leads to additional effort and noise in the common structure and complicates architectural decisions. In this work, we present an automatic approach to identify and filter outlier variants during the recovery and definition of PLAs. Our approach identifies the minimum subset of cross-product architectural information for an effective PLA recovery. To evaluate our approach, we focus on real-world variants of the Apo-Games family. We recover a PLA taking as input 34 Apo-Game variants developed by using opportunistic reuse. The results provided evidence that our automatic approach is able to identify and filter outlier variants, allowing to eliminate exclusive packages and classes without removing the whole variant. We consider that the recovered PLA can help domain experts to take informed decisions to support SPL adoption.

Feature Models Preconfiguration Based on User Profiling

Feature modeling is used to express commonality and variability among a family of software products called the software product line. To offer customized products to their customers, organizations need to build packages of features taking into consideration customer needs and preferences. This paper presents a platform named SPLP (Software Product Line Profiling) which allows pre-configuring feature models through the restriction of the configuration space to meet the requirements of a specific market segment. Considering that concerns and preferences of this latter are a key criteria to achieve a tailored pre-configuration, authors propose the integration of user profiling in the SPLP platform through the definition of a user profile model describing information about the user and the products he is used to consume. This information is then exploited by the SPLP platform to perform an automated pre-configuration according to each user profile requirements and preferences.

Automatic query reformulations for feature location in a model-based family of software products

No maintenance activity can be completed without Feature Location (FL), which is finding the set of software artifacts that realize a particular functionally. Despite the importance of FL, the vast majority of work has been focused on retrieving code, whereas other software artifacts such as the models have been neglected. Furthermore, locating a piece of information from a query in a large repository is a challenging task as it requires knowledge of the vocabulary used in the software artifacts. This can be alleviated by automatically reformulating the query (adding or removing terms). In this paper, we test four existing query reformulation techniques, which perform the best for FL in code but have never been used for FL in models. Specifically, we test these techniques in two industrial domains: a model-based family of firmwares for induction hobs, and a model-based family of PLC software to control trains. We compare the results provided by our FL approach using the query and the reformulated queries by means of statistical analysis. Our results show that reformulated queries do not improve the performance in models, which could lead towards a new direction in the creation or reconsideration of these techniques to be applied in models.

Locating Clone-and-Own Relationships in Model-Based Industrial Families of Software Products to Encourage Reuse

Companies often develop similar product variants that share a high degree of functionality (i.e., features) by copying and modifying code (the clone-and-own approach). In an industrial context with a large amount of variants, software reuse can become complex for engineers. Identifying the clone-and-own relationships between the same features in different product variants can encourage reuse (e.g., suggesting improvements on how features are reused or detecting feature reuse impediments). This paper presents our approach to locate the clone-and-own relationships. To do this, our approach proposes an algorithm that combines feature location and code-comparison techniques. We evaluated our approach in three model-based industrial families of two domains (firmware for induction hobs and train control software). In our evaluation, we measure the performance (in terms of precision and recall) and compare our approach with its previous version (baseline), which uses a different technique to compare the code of each feature with its variants. The results show that our approach is able to locate clone-and-own relationships in different domains of real-world environments, and it outperforms the baseline up to 65.37% in terms of precision.

Improving quality of software product line by analysing inconsistencies in feature models using an ontological rule‐based approach

AbstractIn software product line engineering, feature models (FMs) represent the variability and commonality of a family of software products. The development of FMs may introduce inaccurate feature relationships. These relationships may cause various types of defects such as inconsistencies, which deteriorate the quality of software products. Several researchers have worked on the identification of defects due to inconsistency in FMs, but only a few of them have explained their causes. In this paper, FM is transformed to predicate‐based feature model ontology using Prolog. Further, first‐order logic is employed for defining rules to identify defects due to inconsistency, the explanations for their causes, and suggestions for their corrections. The proposed approach is explained using an FM available in Software Product Line Online Tools repository. It is validated using 26 FMs of discrete sizes up to 5,543 features, generated using the FeatureIDE tool and real‐world FMs. Results indicate that the proposed methodology is effective, accurate, and scalable and improves software product line.

Microsoft Corp.: Branding and Positioning .NET

John Williams, senior director of marketing for Microsoft's .NET, was trying to build the .NET brand, a comprehensive family of next-generation connectivity software products. Highlights the challenges of branding and positioning a complex technology offering. The first challenge facing Microsoft was to develop a common definition of .NET, which had been in flux over the prior two years. The second challenge was to choose between an umbrella branding strategy, a sub-branding strategy, and an ingredient branding strategy. The third challenge was to create a value proposition that would appeal to three very different target audiences: business decision makers, IT professionals, and developers.To analyze the branding and positioning of a complex new technology offering: by defining a new product offering for public understanding and comprehension; evaluating brand strategies for optimal effect, considering possible hurdles to implementation of each strategy; and developing a value proposition attractive to differing audiences.

Effective product-line testing using similarity-based product prioritization

A software product line comprises a family of software products that share a common set of features. Testing an entire product-line product-by-product is infeasible due to the potentially exponential number of products in the number of features. Accordingly, several sampling approaches have been proposed to select a presumably minimal, yet sufficient number of products to be tested. Since the time budget for testing is limited or even a priori unknown, the order in which products are tested is crucial for effective product-line testing. Prioritizing products is required to increase the probability of detecting faults faster. In this article, we propose similarity-based prioritization, which can be efficiently applied on product samples. In our approach, we incrementally select the most diverse product in terms of features to be tested next in order to increase feature interaction coverage as fast as possible during product-by-product testing. We evaluate the gain in the effectiveness of similarity-based prioritization on three product lines with real faults. Furthermore, we compare similarity-based prioritization to random orders, an interaction-based approach, and the default orders produced by existing sampling algorithms considering feature models of various sizes. The results show that our approach potentially increases effectiveness in terms of fault detection ratio concerning faults within real-world product-line implementations as well as synthetically seeded faults. Moreover, we show that the default orders of recent sampling algorithms already show promising results, which, however, can still be improved in many cases using similarity-based prioritization.

IncLing: efficient product-line testing using incremental pairwise sampling

A software product line comprises a family of software products that share a common set of features. It enables customers to compose software systems from a managed set of features. Testing every product of a product line individually is often infeasible due to the exponential number of possible products in the number of features. Several approaches have been proposed to restrict the number of products to be tested by sampling a subset of products achieving sufficient combinatorial interaction coverage. However, existing sampling algorithms do not scale well to large product lines, as they require a considerable amount of time to generate the samples. Moreover, samples are not available until a sampling algorithm completely terminates. As testing time is usually limited, we propose an incremental approach of product sampling for pairwise interaction testing (called IncLing), which enables developers to generate samples on demand in a step-wise manner. Furthermore, IncLing uses heuristics to efficiently achieve pairwise interaction coverage with a reasonable number of products. We evaluated IncLing by comparing it against existing sampling algorithms using feature models of different sizes. The results of our approach indicate efficiency improvements for product-line testing.

Requirement-driven evolution in software product lines: A systematic mapping study

CONTEXT. Software Product Lines (SPLs) aim to support the development of a whole family of software products through systematic reuse of shared assets. As SPLs exhibit a long life-span, evolution is an even greater concern than for single-systems. For the purpose of this work, evolution refers to the adaptation of the SPL as a result of changing requirements. Hence, evolution is triggered by requirement changes, and not by bug fixing or refactoring.OBJECTIVE. Research on SPL evolution has not been previously mapped. This work provides a mapping study along Petersen’s and Kichenham’s guidelines, to identify strong areas of knowledge, trends and gaps.RESULTS. We identified 107 relevant contributions. They were classified according to four facets: evolution activity (e.g., identify, analyze and plan, implement), product-derivation approach (e.g., annotation-based, composition-based), research type (e.g., solution, experience, evaluation), and asset type (i.e., variability model, SPL architecture, code assets and products).CONCLUSION. Analyses of the results indicate that “Solution proposals” are the most common type of contribution (31%). Regarding the evolution activity, “Implement change” (43%) and “Analyze and plan change” (37%) are the most covered ones. A finer-grained analysis uncovered some tasks as being underexposed. A detailed description of the 107 papers is also included.

Trustworthy variant derivation with translation validation for safety critical product lines

Software product line (SPL) engineering facilitates development of entire families of software products with systematic reuse. Model driven SPLs use models in the design and development process. In the safety critical domain, validation of models and testing of code increases the quality of the products altogether. However, to maintain this trustworthiness it is necessary to know that the SPL tools, which manipulate models and code to derive concrete product variants, do not introduce errors in the process.We propose a general technique of checking correctness of product derivation tools through translation validation. We demonstrate it using Featherweight VML—a core language for separate variability modeling relying on a single kind of variation point to define transformations of artifacts seen as object models. We use Featherweight VML with its semantics as a correctness specification for validating outputs of a variant derivation tool. We embed this specification in the theorem proving system Coq and develop an automatic generator of correctness proofs for translation results within Coq. We show that the correctness checking procedure is decidable, which allows the trustworthy proof checker of Coq to automatically verify runs of a variant derivation tool for correctness.We demonstrate how such a simple validation system can be constructed, by using this to validate variant derivation of a simple variability model implementation based on the Eclipse Modeling Framework. We hope that this presentation will encourage other researchers to use translation validation to validate more complex correctness properties in handling variability, as well as demonstrate to commercial tool vendors that formal verification can be introduced into their tools in a very lightweight manner.