Search

Software product lines (SPL) leverage extensive reuse to enhance quality and competitiveness. However, the inherent high testing risks underscore the need for efficient techniques. Test case prioritization (TCP) emerges as a pivotal strategy for improving defect detection by optimizing the arrangement of test cases, thereby maximizing benefits, particularly when testing is prematurely halted. This paper presents a comprehensive review of the latest TCP techniques, investigating emerging trends, varied approaches, and the associated cost-effectiveness trade- offs. Through a systematic literature review spanning from 2011 to 2023 and employing specific search terms, this study scrutinizes the existing body of research. The analysis reveals a growing demand for TCP in research over the past five years, accompanied by a positive upsurge in SPL testing trends. TCP proves instrumental in orchestrating test cases from high to low priority levels, facilitating early defect detection and subsequent error resolution. Nonetheless, notable gaps persist in terms of time execution and coverage, prompting ongoing research efforts aimed at enhancing the cost-effectiveness of TCP. While TCP serves as a potent regression technique in software testing, existing approaches stand to benefit from the reordering of test cases and the integration of refined methodologies gleaned from current research endeavors. [ABSTRACT FROM AUTHOR]

In the software product line (SPL), configuration management (CM) is a multidimensional problem that is taking great attention in software development. Although much research has been developed on this topic, there is no clear view of the current state of it. In this study, we used a systematic method to develop a map of configuration management across product lines to classify relevant literature. The resulting map provides an overview of this research through the identification of the main activities of the CM, the types and trends of research as well as the maturity of existing contributions. Because the CM in SPL is still in its formative stage, we believe that this work will contribute to the process of providing a more common and coherent conceptual basis for its understanding. In addition, it can help to detect important research problems and gaps.

The Software Product Line (SPL) approach receives more attention due to the observed benefits, such as cost reduction, quality improvements, and reduced delivery time. Although organizations are aware of its potential benefits, they face some challenges while creating a clear road map to adopt this approach. Capability maturity models are developed to guide organizations by providing an extensive road map for improvement. Accordingly, we developed a capability maturity model, entitled SPL Capability Maturity Model (SPL‐CMM), to improve an organization's SPL capabilities by enabling the assessment of SPL‐specific processes and providing a guideline for process improvement. SPL‐CMM, developed based on SPICE‐ISO/IEC 330xx standard, has two dimensions of process and capability. The process dimension consists of 16 SPL‐specific processes defined under four process areas: business, architecture, technical, and organization, and the capability dimension has six capability and maturity levels from levels 0 to 5. It is a structured approach assisted by adequate measures with guidance on actions for improvement. A case study was conducted to check the applicability and usefulness of the proposed approach in a software company. The case study results show that SPL‐CMM is applicable for identifying the current state of the SPL process capability and the gaps for process improvement to the next level. [ABSTRACT FROM AUTHOR]

A Software Product Line (SPL) is a set of software products that are built from a variability model. Real-world SPLs typically involve a vast number of valid products, making it impossible to individually test each of them. This arises the need for automated test suite generation, which was previously modeled as either a single-objective or a multi-objective optimization problem considering only objective functions. This article provides a completely different mathematical model by exploiting the benefits of Quality-Diversity (QD) optimization that is composed of not only an objective function (e.g., t-wise coverage or test suite diversity) but also a user-defined behavior space (e.g., the space with test suite size as its dimension). We argue that the new model is more suitable and generic than the two alternatives because it provides at a time a large set of diverse (measured in the behavior space) and high-performing solutions that can ease the decision-making process. We apply MAP-Elites, one of the most popular QD algorithms, to solve the model. The results of the evaluation, on both realistic and artificial SPLs, are promising, with MAP-Elites significantly and substantially outperforming both single- and multi-objective approaches, and also several state-of-the-art SPL testing tools. In summary, this article provides a new and promising perspective on the test suite generation for SPLs. [ABSTRACT FROM AUTHOR]

Software Product Line (SPL) is a group of software-intensive systems that share common and variable resources for developing a particular system. The feature model is a tree-type structure used to manage SPL's common and variable features with their different relations and problem of Crosstree Constraints (CTC). CTC problems exist in groups of common and variable features among the sub-tree of feature models more diverse in Internet of Things (IoT) devices because different Internet devices and protocols are communicated. Therefore, managing the CTC problem to achieve valid product configuration in IoT-based SPL is more complex, time-consuming, and hard. However, the CTC problem needs to be considered in previously proposed approaches such as Commonality VariabilityModeling of Features (COVAMOF) and Genarch + tool; therefore, invalid products are generated. This research has proposed a novel approach Binary Oriented Feature Selection Crosstree Constraints (BOFS-CTC), to find all possible valid products by selecting the features according to cardinality constraints and cross-tree constraint problems in the featuremodel of SPL. BOFS-CTCremoves the invalid products at the early stage of feature selection for the product configuration. Furthermore, this research developed the BOFS-CTC algorithm and applied it to, IoT-based feature models. The findings of this research are that no relationship constraints and CTC violations occur and drive the valid feature product configurations for the application development by removing the invalid product configurations. The accuracy of BOFS-CTC is measured by the integration sampling technique, where different valid product configurations are compared with the product configurations derived by BOFS-CTC and found 100% correct. Using BOFS-CTC eliminates the testing cost and development effort of invalid SPL products. [ABSTRACT FROM AUTHOR]

The software industry is facing more complex computer systems, with short development and sustainability issues. To deliver good software with these constraints, software reuse has become a central concept for minimizing design and realization costs. This study improves upon Feature-Oriented Reuse Method with Business Component Semantics (FORM/BCS), a software development method that produces adaptable architectures from reusable domain components. This is a promising method for reusable software assets and model creation. The objective of the FORM/BCS is to bring the industrial production chain to the software. This study proposes a model to automatically transform the FORM/BCS business subsystem component into a process business component. Two metamodels for business subsystems and process business components were developed. In addition, this study establishes correspondences between the source metamodel and target metamodel classes, transformation rules, and the instance of the source metamodel and generates the target metamodel instance. Detailed findings can help practitioners reduce software design costs and development time, and contribute to the advancement of knowledge in software engineering.

One way of developing fast, effective, and high-quality software products is to reuse previously developed software components and products. In the case of a product family, the software product line (SPL) approach can make reuse more effective. The goal of SPLs is faster development of low-cost and high-quality software products. This paper proposes an incremental model-based approach to test products in SPLs. The proposed approach utilizes event-based behavioral models of the SPL features. It reuses existing event-based feature models and event-based product models along with their test cases to generate test cases for each new product developed by adding a new feature to an existing product. Newly introduced featured event sequence graphs (FESGs) are used for behavioral feature and product modeling; thus, generated test cases are event sequences. The paper presents evaluations with three software product lines to validate the approach and analyze its characteristics by comparing it to the state-of-the-art ESG-based testing approach. Results show that the proposed incremental testing approach highly reuses the existing test sets as intended. Also, it is superior to the state-of-the-art approach in terms of fault detection effectiveness and test generation effort but inferior in terms of test set size and test execution effort.

Objectives: This work presents the application of meta-modeling to the data visualization and dashboards' domain to obtain two main products: a system that allows the instantiation of the meta-model through a graphical interface and a code generator that takes the instantiation of the meta-model as an input to generate visualizations and dashboards. Methods: A domain engineering approach complemented with an example-driven methodology was iteratively employed to develop the dashboard meta-model. This meta-model was subsequently used as an input to implement a code generator of information dashboards. These two artifacts were finally combined to design and develop the architecture of MetaViz. Results: Through this process, it was possible to generate visualizations and dashboards using visual elements and basic interactions. MetaViz allows the generation of basic charts (line charts, scatter plots, pie charts, etc.) as well as more complex displays with interactive behavior along different views, layouts, and operations. Conclusions: The development of MetaViz has served as proof of the viability and benefits of applying these methodologies to a complex domain, but also to set the foundations of a system that allows users to trace every single element from a data visualization to its most primitive values.

Product detection based on state abstraction technologies in the software product line (SPL) is more complex when compared to a single system. This variability constitutes a new complexity, and the counterexample may be valid for some products but spurious for others. In this paper, we found that spurious products are primarily due to the failure states, which correspond to the spurious counterexamples. The violated products correspond to the real counterexamples. Hence, identifying counterexamples is a critical problem in detecting violated products. In our approach, we obtain the violated products through the genuine counterexamples, which have no failure state, to avoid the tedious computation of identifying spurious products dealt with by the existing algorithm. This can be executed in parallel to improve the efficiency further. Experimental results show that our approach performs well, varying with the growth of the system scale. By analyzing counterexamples in the abstract model, we observed that spurious products occur in the failure state. The approach helps in identifying whether a counterexample is spurious or genuine. The approach also helps to check whether a failure state exists in the counterexample. The performance evaluation shows that the proposed approach helps significantly in improving the efficiency of abstraction-based SPL model checking. [ABSTRACT FROM AUTHOR]

Copyright of Dokuz Eylul University Muhendislik Faculty of Engineering Journal of Science & Engineering / Dokuz Eylül Üniversitesi Mühendislik Fakültesi Fen ve Mühendislik Dergisi is the property of Dokuz Eylul Universitesi Muhendislik Fakultesi Fen ve Muhendislik Dergisi and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

The specifications of a certain domain are addressed by a portfolio of software products, known as Software Product Line (SPL). Feature Model (FM) supports domain engineering by modeling domain knowledge along with variability among SPL. The quality of FM is one of the significant factors for the successful SPL in order to attain high quality software products. However, the benefits of SPL can be reduced due to defects in FM. Dead Feature (DF) is one of such defects. Several approaches exist in the literature to detect defects due to DF in FMs. But only a few can handle their sources and solutions which are cumbersome and difficult to understand by humans. An ontological knowledge-based method for handling defects due to DF in FMs is described in this paper. It specifies FM in the form of ontology-based knowledge representation. The rules based on first-order logic are created and implemented using Prolog to detect defects due to DF with sources as well as suggest solutions to resolve these defects. A case study of the product line available on SPLOT repository is utilized for illustrating the proposed work. The experiments are performed with real-world FMs of varied sizes from SPLOT and FMs created with the FeatureIDE tool. The results prove the efficiency, scalability (up to model with 32,000 features) and accuracy of the presented method. Therefore, reusability of DFs free knowledge enables deriving defect free products from SPL and eventually enhances the quality of SPL. [ABSTRACT FROM AUTHOR]

This work presents the application of meta-modeling to the data visualization and dashboards' domain to obtain two main products: a system that allows the instantiation of the meta-model through a graphical interface and a code generator that takes the instantiation of the meta-model as an input to generate visualizations and dashboards. A domain engineering approach complemented with an example-driven methodology was iteratively employed to develop the dashboard meta-model. This meta-model was subsequently used as an input to implement a code generator of information dashboards. These two artifacts were finally combined to design and develop the architecture of MetaViz. Through this process, it was possible to generate visualizations and dashboards using visual elements and basic interactions. MetaViz allows the generation of basic charts (line charts, scatter plots, pie charts, etc.) as well as more complex displays with interactive behavior along different views, layouts, and operations. The development of MetaViz has served as proof of the viability and benefits of applying these methodologies to a complex domain, but also to set the foundations of a system that allows users to trace every single element from a data visualization to its most primitive values. [ABSTRACT FROM AUTHOR]

To improve the maintenance and quality of software product lines, efficient configurations techniques have been proposed. Nevertheless, due to the complexity of derived and configured products in a product line, the configuration process of the software product line (SPL) becomes timeconsuming and costly. Each product line consists of a various number of feature models that need to be tested. The different approaches have been presented by Search-based software engineering (SBSE) to resolve the software engineering issues into computational solutions using some metaheuristic approach. Hence, multiobjective evolutionary algorithms help to optimize the configuration process of SPL. In this paper, different multi-objective Evolutionary Algorithms like Non-Dominated Sorting Genetic algorithms II (NSGA-II) and NSGA-III and Indicator based Evolutionary Algorithm (IBEA) are applied to different feature models to generate optimal results for large configurable. The proposed approach is also used to generate the optimized test suites with the help of different multi-objective Evolutionary Algorithms (MOEAs). [ABSTRACT FROM AUTHOR]

In the early stages of a system of systems (SoS) conception, several constituent systems could be available that provide similar functionalities. An SoS design methodology should provide adequate means to model variability in order to support the opportunistic selection of the most desirable SoS configuration. We propose the VANTESS approach that (i) supports SoS modeling taking into account the variation points implied by the considered constituent systems; (ii) includes a heuristics to weight benefits and costs of potential architectural choices (called as SoS variants) for the selection of the constituent systems; and finally (iii) also helps test planning for the selected SoS variant by deriving a simulation model on which test objectives and scenarios can be devised. We illustrate an application example of VANTESS to the "educational" SoS and discuss its pros and cons within a focus group. [ABSTRACT FROM AUTHOR]

FM Fact Label is a tool for visualizing the characterizations of feature models based on their metadata, structural measures, and analytical metrics. Although there are various metrics available to characterize feature models, there is no standard method to visualize and identify unique properties of feature models. Unlike existing tools, FM Fact Label provides a standalone web-based platform for configurable and interactive visualization, enabling export to various formats. This contribution is significant because it supports the Universal Variability Language (UVL) and enhances the UVL ecosystem by offering a common representation of the results of existing analysis tools. [ABSTRACT FROM AUTHOR]

Context: Testing is one of the techniques that can assure the quality of software including the domain of Software Product Line (SPL). Various techniques have been deliberated to enhance the quality of SPL including Model-based Testing (MBT). Objective: The objective of this study is to analyze and classify trends of MBT in SPL covering the solutions, issues and evaluation aspects by using taxonomy form. Method: A Systematic Literature Review (SLR) was conducted involving 63 primary studies from different sources. The selected studies were categorized based on their common characteristics. Results: Several findings can guide future research on MBT for SPL. The important finding is that the multiple measurements are still open to improving current metrics to evaluate test cases in MBT for SPL. The multiple types of measurement required a trade-off between maximization and minimization results to ensure the testing method which could satisfy multiple test criteria for example cost and effectiveness at the same time. [ABSTRACT FROM AUTHOR]

Software product lines (SPL) are used in industry to achieve more efficient software development. However, efficient configuration management system is crucial for the success of any SPL. Very few approaches are found on software configuration management (SCM) in SPL. This study aims at surveying existing research on SCM in SPL in order to identify useful approaches and needs for future research. A systematic mapping study was conducted to find as much literature as possible between 2010-2020, and the twenty three papers found were classified according to context, research and contribution type. Most research effort is spent on product variability (87%) with contributions such as proposed tools and models (70%), sketched out in detail but not yet evaluated, i.e. solution proposals (63.33%). According to the results found, more validation and evaluation research of the SCM is needed to provide a better foundation for SPL. [ABSTRACT FROM AUTHOR]

• We study the logical and extensional representations of feature models. • We study the logical and extensional representations of attributed feature models. • We investigate the algebraic properties of operations and relations on the extensional representations of both models. • We identify the logical counterpart of the above relations and operations for both basic and attributed feature models. • We show that these operations and relations have meaning in lattices. Software-intensive systems can have thousands of interdependent configuration options across different subsystems. Feature models (FMs) allow designers to organize the configuration space by describing configuration options using interdependent features: a feature is a name representing some functionality and each software variant is identified by a set of features. Attributed feature models (AFMs) extend FMs to describe the, possibly constrained, choice of a value from domains such as integers or strings: each attribute is associated to one feature, and when the feature is selected then the attribute brings some additional information relative to the selected features. Different representations of FMs and AFMs have been proposed in the literature. In this paper we focus on the logical representation (which works well in practice) and the extensional representation (which has been recently shown well suited for theoretical investigations). We provide an algebraic and a logical characterization of operations and relations on FMs and AFMs, and we formalize the connection between the two characterizations as monomorphisms from lattices of logical FMs and AFMs to lattices of extensional FMs and AFMs, respectively. This formalization sheds new light on the correspondence between the algebraic and logical characterizations of operations and relations for FMs and AFMs. It aims to foster the development of a formal framework for supporting practical exploitation of future theoretical developments on FMs, AFMs and multi software product lines. [ABSTRACT FROM AUTHOR]

In the context of software product line (SPL) engineering, test cases can be reused for testing a family of products that share common parts of source code. An approach to test the products of a product family is to exhaustively execute each test case on all the products. However, such an approach would be very inefficient because the common parts of source code will be tested multiple times unnecessarily. To reduce unnecessary repetition of testing, we previously proposed a method to avoid equivalent test executions of a product line in the context of regression testing. However, it turns out that the same approach can be used in a broader context than just regression testing of product families. In this paper, we argue the generality of the method in the sense that it can be used for testing of the first version of a product family as well as regression testing of its subsequent versions. In addition, in this paper, in order to make the method practically usable for users, we propose a process for applying it to SPL testing. We demonstrate the generality of our method and the practical applicability of the proposed process for the method by conducting a case study. [ABSTRACT FROM AUTHOR]

Software Product Line (SPL) developments include Variability Management (VA) as a core activity aiming at minimizing the inherent complexity in commonality and variability manipulation. Particularly, the (automated) analysis of variability models refers to the activities, methods and techniques involved in the definition, design, and instantiation of variabilities modeled during SPL development. Steps of this analysis are defined as a variability analysis process (VA process), which is focused on assisting variability model designers in avoiding anomalies and/or inconsistencies, and minimizing problems when products are implemented and derived. Previously, we have proposed an approach for analyzing variability models through a well-defined VA process (named SeVaTax). This process includes a comprehensive set of scenarios, which allows a designer to detect (and even correct in some cases) different incompatibilities. In this work, we extend SeVaTax by classifying the scenarios according to their dependencies, and by assessing the use of these scenarios. This assessment introduces two experiments to evaluate accuracy and coverage. The former addresses responses when variability models are analyzed, and the latter the completeness of our process with respect to other proposals. Findings show that a more extensive set of scenarios might improve the possibilities of current practices in variability analysis. [ABSTRACT FROM AUTHOR]

In highly configurable information systems such as SaaS information systems, business process variability management is an important issue. The variability model, which is often called the configurable process model (CPM), can be reused to configure a family of processes each serving a separate purpose or customer. If not already present, these business process variability models have to be "extracted" based on event logs residing in the databases of the target enterprise(s). Such extraction is costly to carry out manually. In this study, inspired by Software Product Line Engineering concepts, we propose a novel automated process-mining-based method by extending the "Alpha" algorithm for process discovery as a preliminary solution. The proposed method takes a set of event logs as input; and in three phases, outputs a CPM in terms of a model called "BPFM". To evaluate the method, we used the Goal-Question-Metric approach in a case study on 10 cases. For this purpose, input event logs were artificially extracted from the cases' existing BPFM models and were fed as input to the proposed method. Then, we observed if the output models of the method were similar to the preliminary existing ones. The results showed that the method was promising in identifying the CPMs; since the extracted models involved activities that were 97.5% identical to what was expected. Moreover, a structural precision of 98% and a structural recall of 97.3% were obtained. The set of configurations derivable from the output models was 100% similar to and provided 100% coverage over the expected configurations. [ABSTRACT FROM AUTHOR]

Feature modeling is a common approach for configuring and capturing commonalities and variations among different Software Product Lines (SPL) products. This process is carried out by a set of SPL design teams, each working on a different configuration of the desired product. The integration of these configurations leads to inconsistencies in the final product design. The typical solution involves extensive deliberation and unnecessary resource usage, which makes SPL inconsistency resolution an expensive and unoptimized process. We present the first comprehensive evaluation of swarm intelligence (using Particle Swarm Optimization) to the problem of resolving inconsistencies in a configured integrated SPL product. We call it o-SPLIT (optimization-based Software Product LIne Tool) and validate o-SPLIT with standard ERP, SPLOT (Software Product Lines Online Tools), and BeTTy (BEnchmarking and TesTing on the analYsis) product configurations along with diverse feature set sizes. The results show that Particle Swarm Optimization can successfully optimize SPL product configurations. Finally, we implement o-SPLIT as a decision-support tool in a real, local SPL setting and acquire subjective feedback from SPL designers which shows that the teams are convinced of the usability and high-level decision support provided by o-SPLIT.

Agile software development (ASD) and software product line (SPL) have shown significant benefits for software engineering processes and practices. Although both methodologies promise similar benefits, they are based on different foundations. SPL encourages systematic reuse that exploits the commonalities of various products belonging to a common domain and manages their variations systematically. In contrast, ASD stresses a flexible and rapid development of products using iterative and incremental approaches. ASD encourages active involvement of customers and their frequent feedback. Both ASD and SPL require alternatives to extend agile methods for several reasons such as (1) to manage reusability and variability across the products of any domain, (2) to avoid the risk of developing core assets that will become obsolete and not used in future projects, and (3) to meet the requirements of changing markets. This motivates the researchers for the integration of ASD and SPL approaches. As a result, an innovative approach called agile product line engineering (APLE) by integrating SPL and ASD has been introduced. The principal aim of APLE is to maximize the benefits of ASD and SPL and address the shortcomings of both. However, combining both is a major challenge. Researchers have proposed a few approaches that try to put APLE into practice, but none of the existing approaches cover all APLE features needed. This paper proposes a new dynamic variability approach for APLE that uses APLE practices for reusing features. The proposed approach (PA) is based on the agile method Scrum and the reactive approach of SPL. In this approach, reusable core assets respond reactively to customer requirements. The PA constructs and develops the SPL architecture iteratively and incrementally. It provides the benefits of reusability and maintainability of SPLs while keeping the delivery-focused approach from agile methods. We conducted a quantitative survey of software companies applying the APLE to assess the performance of the PA and hypotheses of empirical study. Findings of empirical evaluation provide evidence on integrating ASD and SPL and the application of APLE into practices. [ABSTRACT FROM AUTHOR]

Internet of things (IoT) architecture needs to adapt autonomously to the environment and operational to maintain their supreme services. One common problem in the IoT architecture is to manage the reliability of data services, such as sensors' data, that only sending data to the collector via gateway. If there is a disruption of services, then it is not easy to manage the system reliability. To this, an adaptive environment which is based on software reconfiguration creates a great challenge to provide better services. In this work, the software product line engineering (SPLE) reconfigures the edge devices via rules and software architecture. To identify disruption of data services which can be detected based on anomaly and truncated data. Our work makes use of concept drift to provide a recommendation to the system manager. This is important to avoid misconfiguration in the system We demonstrate our method using an open-source internet of things portal system that integrated to a cluster of sensors which is attached to specific gateway before the data are collected into a cloud storage for further processes. In identifying drifting data, the adaptive sliding window (ADWIN) method outperforms the Page-Hinkley (PH) with more selective identification and sensitive reading. [ABSTRACT FROM AUTHOR]

Dealing with variability, during Software Product Line Engineering (SPLE), means trying to allow software engineers to develop a set of similar applications based on a manageable range of variable functionalities according to expert users' needs. Particularly, variability management (VM) is an activity that allows flexibility and a high level of reuse during software development. In the last years, we have witnessed a proliferation of methods, techniques and supporting tools for VM in general, and for its analysis in particular. More precisely, a specific field has emerged, named (automated) variability analysis, focusing on verifying variability models across the SPLE's phases. In this paper, we introduce a systematic literature review of existing proposals (as primary studies) focused on analyzing variability models. We define a classification framework, which is composed of 20 sub-characteristics addressing general aspects, such as scope and validation, as well as model-specific aspects, such as variability primitives, reasoner type. The framework allows to look at the analysis of variability models during its whole life cycle—from design to derivation—according to the activities involved during an SPL development. Also, the framework helps us answer three research questions defined for showing the state of the art and drawing challenges for the near future. Among the more interesting challenges, we can highlight the needs of more applications in industry, the existence of more mature tools, and the needs of providing more semantics in the way of variability primitives for identifying inconsistencies in the models. [ABSTRACT FROM AUTHOR]

Patient Navigation Program (PNP) is considered as an important implementation of health care systems that can assist in patient’s treatment. Due to the feasibility of PNP implementation, a systematic reuse is needed for a wide adoption of PNP computerized system. SPL is one of the promising systematic reuse approaches for creating a reusable architecture to enabled reuse in several similar applications of PNP systems which has its own variations with other applications. However, stakeholder decision making which result from the imprecise, uncertain,and subjective nature of architecture selection based on quality attributes (QA) further hinders the development of the product line architecture. Therefore, this study aims to propose a quality-driven approach using Multi-Criteria Decision Analysis (MCDA) techniques for Software Product Line Architecture (SPLA) to have an objective selection based on the QA of stakeholders in the domain of PNP. There are two steps proposed to this approach. First, a clear representation of quality is proposed by extending feature model (FM) with QA feature to determine the QA in the early phase of architecture selection. Second, MCDA techniques were applied for architecture selection based on objective preference for certain QA in the domain of PNP. The result of the proposed approach is the implementation of the PNP system with SPLA that had been selected using MCDA techniques. Evaluation for the approach is done by checking the approach’s applicability in a case study and stakeholder validation. Evaluation on ease of use and usefulness of the approach with selected stakeholders have shown positive responses. The evaluation results proved that the proposed approach assisted in the implementation of PNP systems. [ABSTRACT FROM AUTHOR]

In the current application development strategies, families of products are developed with personalized configurations to increase stakeholders' satisfaction. Product lines have the ability to address several requirements due to their reusability and configuration properties. The structuring and prioritizing of configuration requirements facilitate the development processes, whereas it increases the conflicts and inadequacies. This results in increasing human effort, reducing user satisfaction, and failing to accommodate a continuous evolution in configuration requirements. To address these challenges, we propose a framework for managing the prioritization process considering heterogeneous stakeholders priority semantically. Features are analyzed, and mined configuration priority using the data mining method based on frequently accessed and changed configurations. Firstly, priority is identified based on heterogeneous stakeholder's perspectives using three factors functional, experiential, and expressive values. Secondly, the mined configuration is based on frequently accessed or changed configuration frequency to identify the new priority for reducing failures or errors among configuration interaction. We evaluated the performance of the proposed framework with the help of an experimental study and by comparing it with analytical hierarchical prioritization (AHP) and Clustering. The results indicate a significant increase (more than 90 percent) in the precision and the recall value of the proposed framework, for all selected cases. [ABSTRACT FROM AUTHOR]

Software Product Lines (SPLs) constitute a popular method for encouraging the methodical reuse of software artefacts. Just like any other piece of software, SPLs require management throughout their evolution, namely to preserve the consistency between requirements and the code. Over time, for a given SPL, many change requests are made and all of them need to be integrated in a consistent and coordinated way. The evolution of an SPL is facilitated if there exist links between its artefacts, namely between each feature and its respective pieces of implementation code. This paper proposes FMap, a systematic feature mapping approach to be used within SPLs. FMap traces a Feature Model (FM) to other artefacts of an SPL, the reference architecture, and the code, and it establishes connections between each feature of the FM and its locations in the code-base. Additionally, we have created a tool called friendlyMapper to provide some automatic support for the approach. Using two case studies from two different companies, FMap and friendlyMapper are evaluated. The evaluation of the case studies indicates that the FMap approach outperforms the baseline approach (i.e., the branching approach). This work contributes with FMap, a novel tool-based approach that supports feature-architecture-code mappings based on reference architecture. FMap assists software engineers in adapting the evolution of the SPLs to accommodate new features and change requests as the SPLs evolve. The case studies for both companies demonstrate that the approach is applicable to real-world products and is able to support feature traceability and maintain consistency among features, architecture, and code. [ABSTRACT FROM AUTHOR]

Interactive Digital TV (iDTV) enhances viewers’ experience and participation by engaging them with an active role. The development of interactive software requires the employment of usability criteria to provide satisfactory experiences for users. In addition, the diverse characteristics of television programs require efficient processes for interactive software development. In Latin America, the process of implementing DTV is in progress, so the current stage of development of interactive applications is too incipient and immature to support industrial, quality-level development. This paper proposes combining software reuse strategies, specifically, software product lines (SPLs) and user-centered interaction design patterns, to improve productivity and quality. A generic feature model for the automatic generation of iDTV applications and an SPL-iDTV tool that supports the model are presented. The proposal is evaluated with two studies: an experiment that attempts to reproduce real application prototypes that were originally developed manually, through the use of patterns, and an evaluation of the quality of the SPL.

In software products line (SPL), there may be features which can be implemented by different components, which means there are several implementations for the same feature. In this context, the selection of the best components set to implement a given configuration is a challenging task due to the high number of combinations and options which could be selected. In certain scenarios, it is possible to find information associated with the components which could help in this selection task, such as user ratings. In this paper, we introduce a component-based recommender system, called (REcommender System that suggests implementation Components from selecteD fEatures), which uses information associated with the implementation components to make recommendations in the domain of the SPL configuration. We also provide a RESDEC reference implementation that supports collaborative-based and content-based filtering algorithms to recommend (i.e., implementation components) regarding WordPress-based websites configuration. The empirical results, on a knowledge base with 680 plugins and 187 000 ratings by 116 000 users, show promising results. Concretely, this indicates that it is possible to guide the user throughout the implementation components selection with a margin of error smaller than 13% according to our evaluation.

A software product line is a kind of software, which generates software products with similar functionality by reusing assets. A feature model is extracted from requirements documents to represent each functional module of a software product line and the relationship among functionality. During the evolution of a software product line, a feature model always needs to be rebuilt. The rebuilding process cannot guarantee the correctness of the reconstructed feature model. Therefore, we propose a method of automatically evolving feature models of software product lines with evolutionary requirements to solve the repeated reconstruction and reduce errors in reconstruction. In the method, a formal model of feature models is constructed by communication membrane calculus, then the formal evolutionary requirements can change the formal model automatically, finally the changed formal model is mapped to the reconstructed feature model. The several experiments are carried out by open feature models, and the results of experiments not only verify the effectiveness of the proposed method but also show the method can be used to test whether the software product line evolves according to the requirements. The method can automatically change feature models of software product lines to avoid mistakes when people modify the feature model.

A Software Product Line (SPL) is a collection of software for configuring software products in which sets of features are configured by different teams of product developers. This process often leads to inconsistencies (or dissatisfaction of constraints) in the resulting product configurations, whose resolution consumes considerable business resources. In this paper, we aim to solve this problem by learning, or mathematically modeling, all previous patterns of feature selection by SPL developers, and then use these patterns to predict inconsistent configuration patterns at runtime. We propose and implement an informative Predictive Analytics tool called predictive Software Product LIne Tool (p-SPLIT) which provides runtime decision support to SPL developers in three ways: 1) by identifying configurations of feature selections (patterns) that lead to inconsistent product configurations, 2) by identifying feature selection patterns that lead to consistent product configurations, and 3) by predicting feature inconsistencies in the product that is currently being configured (at runtime). p-SPLIT provides the first application of Predictive Analytics for the SPL feature modeling domain at the application engineering level. With different experiments in representative SPL settings, we obtained 85% predictive accuracy for p-SPLIT and a 98% Area Under the Curve (AUC) score. We also obtained subjective feedback from the practitioners who validate the usability of p-SPLIT in providing runtime decision support to SPL developers. Our results prove that p-SPLIT technology is a potential addition for the global SPL product configuration community, and we further validate this by comparing p-SPLIT's characteristics with state-of-the-art SPL development solutions.

Background The 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. Methods Empirical 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. Results The 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.

The effectiveness of testing in Model-based Testing (MBT) for Software Product Line (SPL) can be achieved by considering fault detection in test case. The lack of fault consideration caused test case in test suite to be listed randomly. Test Case Prioritization (TCP) is one of regression techniques that is adaptively capable to detect faults as early as possible by reordering test cases based on fault detection rate. However, there is a lack of studies that measured faults in MBT for SPL. This paper proposes a Test Case Prioritization (TCP) approach based on dissimilarity and string based distance called Last Minimal for Local Maximal Distance (LM-LMD) with Dice-Jaro-Winkler Dissimilarity. LM-LMD with Dice-Jaro-Winkler Dissimilarity adopts Local Maximum Distance as the prioritization algorithm and Dice-Jaro-Winkler similarity measure to evaluate distance among test cases. This work is based on the test case generated from statechart in Software Product Line (SPL) domain context. Our results are promising as LM-LMD with Dice-Jaro-Winkler Dissimilarity outperformed the original Local Maximum Distance, Global Maximum Distance and Enhanced All-yes Configuration algorithm in terms of Average Fault Detection Rate (APFD) and average prioritization time. [ABSTRACT FROM AUTHOR]

Software product line (SPL) engineering allows the derivation of products tailored to stakeholders’ needs through the setting of a large number of configuration options. Unfortunately, options and their interactions create a huge configuration space which is either intractable or too costly to explore exhaustively. Instead of covering all products, machine learning (ML) approximates the set of acceptable products (e.g., successful builds, passing tests) out of a training set (a sample of configurations). However, ML techniques can make prediction errors yielding non-acceptable products wasting time, energy and other resources. We apply adversarial machine learning techniques to the world of SPLs and craft new configurations faking to be acceptable configurations but that are not and vice-versa. It allows to diagnose prediction errors and take appropriate actions. We develop two adversarial configuration generators on top of state-of-the-art attack algorithms and capable of synthesizing configurations that are both adversarial and conform to logical constraints. We empirically assess our generators within two case studies: an industrial video synthesizer (MOTIV) and an industry-strength, open-source Web-app configurator (JHipster). For the two cases, our attacks yield (up to) a 100% misclassification rate without sacrificing the logical validity of adversarial configurations. This work lays the foundations of a quality assurance framework for ML-based SPLs. [ABSTRACT FROM AUTHOR]

Software Product Line (SPL) developments include Variability Management (VA) as a core activity aiming at minimizing the inherent complexity in commonality and variability manipulation. Particularly, the (automated) analysis of variability models refers to the activities, methods and techniques involved in the definition, design, and instantiation of variabilities modeled during SPL development. Steps of this analysis are defined as a variability analysis process (VA process), which is focused on assisting variability model designers in avoiding anomalies and/or inconsistencies, and minimizing problems when products are implemented and derived. Previously, we have proposed an approach for analyzing variability models through a well-defined VA process (named SeVaTax). This process includes a comprehensive set of scenarios, which allows a designer to detect (and even correct in some cases) different incompatibilities. In this work, we extend SeVaTax by classifying the scenarios according to their dependencies, and by assessing the use of these scenarios. This assessment introduces two experiments to evaluate accuracy and coverage. The former addresses responses when variability models are analyzed, and the latter the completeness of our process with respect to other proposals. Findings show that a more extensive set of scenarios might improve the possibilities of current practices in variability analysis.

Software product line (SPL) is one of the most recent and effective reuse approaches. SPL derives several products from the core artefacts. SPL engineering includes two processes: domain engineering, which identifies the common and variable features to develop the core artefacts, and application engineering, which reuses the core artefacts to derive products. Once the artefacts are reused across multiple products, quality assessment is necessary to prevent inconsistencies from spreading across all SPL products. There are several frameworks and standards, as ISO/IEC 25010:2011, to evaluate quality characteristics. In this study, the authors provide an overview of the SPL quality assessment. Therefore, they perform a systematic mapping to compile and synthesise data regarding the quality characteristics assessed in studies from 2000 to 2019. The results include the identification of 346 metrics applied in 16 software properties to evaluate three quality characteristics of the ISO/IEC 25010:2011. Additionally, they find the domain engineering evaluation frequently occurs regarding the maintainability characteristic. Moreover, they provide analyses of the: (i) metrics used by programming paradigm, (ii) metrics used by software properties, (iii) software properties evaluated for each quality characteristic, (iv) tools used to extract metrics, (v) systems used as benchmarks, and (vi) datasets used for extracting metrics. [ABSTRACT FROM AUTHOR]

Product line (PL)-based development is a thriving research area to develop software-intensive systems. Feature models (FMs) facilitate derivation of valid products from a PL by managing commonalities and variabilities among software products. However, the researchers in academia as well as in the industries experience difficulties in quality assessment of FMs. The increasing complexity and size of FMs may lead to defects, which outweigh the benefits of PL. This paper provides a systematic literature review and key research issues related to the FM defects in PL. We derive a typology of FM defects according to their level of importance. The information on defects' identification and explanations are provided with formalization. Further, corrective explanations are presented which incorporates various techniques used to fix defects with their implementation. This information would help software engineering community by enabling developers or modelers to find the types of defects and their causes and to choose an appropriate technique to fix defects in order to produce defect-free products from FMs, thereby enhancing the overall quality of PL-based development. [ABSTRACT FROM AUTHOR]

This paper studied methods for tracking software product lines, and based on demand analysis, design and realization of information transmission in the domain of software product line, it proposed a multi-layer software product line tracking model based on scenario metamodel, and described of the overall framework for tracking information changes completely. It established requirements-used case tracking matrix, used case-action tracking matrix and action-component tracking matrix. According to matrix operation, it described the implementation process of tracking, and used an A TM case to verify that the method has a good effect on requirements acquisition in software product line and difficulty in requirement change. [ABSTRACT FROM AUTHOR]

Model-driven engineering involves the construction of models on different levels of abstraction. Software engineers are supported by model transformations, which automate the transition from high- to low-level models. Product line engineering denotes a systematic process that aims at developing different product variants from a set of reusable assets. When model-driven engineering is combined with product line engineering, engineers have to deal with multi-variant models. In annotative approaches to product line engineering, model elements are decorated with annotations, i.e., Boolean expressions that define the product variants in which model elements are to be included. In model-driven product line engineering, domain engineers require multi-variant transformations, which create multi-variant target models from multi-variant source models. We propose a reuse-based gray-box approach to realizing multi-variant model transformations. We assume that single-variant transformations already exist, which have been developed for model-driven engineering, without considering product lines. Furthermore, we assume that single-variant transformations create traces, which comprise the steps executed in order to derive target models from source models. Single-variant transformations are extended into multi-variant transformations by trace-based propagation: after executing a single-variant transformation, the resulting single-variant target model is enriched with annotations that are calculated with the help of the transformation's trace. This approach may be applied to single-variant transformations written in different languages and requires only access to the trace, not to the respective transformation definition. We also provide a correctness criterion for trace-based propagation, and a proof that this criterion is satisfied under the prerequisites of a formal computational model. [ABSTRACT FROM AUTHOR]

Software Product Line Engineering (SPLE) is a set of methods to help build a collection of software systems which are similar enough to enable appropriate artefact reuse. An important task consists in documenting in variability models the common and variable features which may compose the similar software systems along with compatibility constraints between these features. Several models and formalisms have been proposed to model variability: each one of them has specific properties making it pertinent to support certain management operations, which are of primary importance in SPLE. Switching from one kind of variability model to another is thus important to benefit from a wide range of operations and efficiently manage a software product line. In this paper, we review the various approaches proposed to manage and organise features and product configurations (a product configuration being a chosen subset of features). We discuss the originality of concept lattices, canonical structures presenting a dual view on features and configurations, and the advantages to use these structures as variability representations. Switching from existing variability models to an equivalent concept lattice raises scaling issues related to the size of the needed input dataset and thus hinders their exploitation. We propose an alternative relying on implicative systems and define a transformation method which does not suffer from scaling issues. [ABSTRACT FROM AUTHOR]

The Software Product Line (SPL) is the mandatory requirement of software industry as SPL minimizes the use of resources, reduces the cost of the system and maximizes the possibility of achieving the objective. The challenge with SPL is that it is exponential to number of features, hence there arises need to optimize the system. The metaheuristic algorithm provides this opportunity of optimize the SPL system. This paper presents BBO algorithm which is used for optimizing feature selection problem in SPL. Further, an empirical study against 10 features model has been done and compare results with Genetic Algorithm (GA).It is noticed that BBO provides best feature subsets for SPL. [ABSTRACT FROM AUTHOR]

Traditional software development methods rarely can reuse accumulated development experiments when developed same system, and cause vast repetitive work. In view of the problem, development method of software product line was proposed and applied into the software development for coal mine safety monitoring and control system. On the basis of analysis of product line of the system, relationships among characteristics of the system were discussed according to commonality and variability characteristics of the system, variability model of the coal mine safety monitoring and control field based on feature modeling method of variability was built. The model can effectively manage variability of the system, and can quickly complete requirements analysis of specific customized monitoring and control system under guidance of the characteristics dependency rules at the same time, which lays foundation for following realization of reusable framework in the coal mine safety monitoring and control field.

Software product line (SPL) is extensively used for reusability of resources in family of products. Feature modeling is an important technique used to manage common and variable features of SPL in applications, such as Internet of Things (IoT). In order to adopt SPL for application development, organizations require information, such as cost, scope, complexity, number of features, total number of products, and combination of features for each product to start the application development. Application development of IoT is varied in different contexts, such as heat sensor indoor and outdoor environment. Variability management of IoT applications enables to find the cost, scope, and complexity. All possible combinations of features make it easy to find the cost of individual application. However, exact number of all possible products and features combination for each product is more valuable information for an organization to adopt product line. In this paper, we have proposed binary pattern for nested cardinality constraints (BPNCC), which is simple and effective approach to calculate the exact number of products with complex relationships between application's feature models. Furthermore, BPNCC approach identifies the feasible features combinations of each IoT application by tracing the constraint relationship from top-to-bottom. BPNCC is an open source and tool-independent approach that does not hide the internal information of selected and non-selected IoT features. The proposed method is validated by implementing it on small and large IoT application feature models with “n” number of constraints, and it is found that the total number of products and all features combinations in each product without any constraint violation.

Cybersecurity attacks affect the compliance of cybersecurity policies of the organisations. Such disadvantages may be due to the absence of security configurations or the use of default configuration values of software products and systems. The complexity in the configuration of products and systems is a known challenge in the software industry since it includes a wide range of parameters to be taken into account. In other contexts, the configuration problems are solved using Software Product Lines. This is the reason why in this article the framework Cybersecurity Software Product Line (CyberSPL) is proposed. CyberSPL is based on a methodology to design product lines to verify cybersecurity policies according to the possible configurations. The patterns to configure the systems related to the cybersecurity aspects are grouped by defining various feature models. The automated analysis of these models allows us to diagnose possible problems in the security configurations, reducing or avoiding them. As support for this proposal, a multi-user and multi-platform solution has been implemented, enabling setting a catalogue of public or private feature models. Moreover, analysis and reasoning mechanisms have been integrated to obtain all the configurations of a model, to detect if a configuration is valid or not, including the root cause of problems for a given configuration. For validating the proposal, a real scenario is proposed where a catalogue of four different feature models is presented. In this scenario, the models have been analysed, different configurations have been validated, and several configurations with problems have been diagnosed. [ABSTRACT FROM AUTHOR]