Software Product Line Approach Research Articles

Data visualization guidance using a software product line approach

Data visualization aims to convey quantitative and qualitative information effectively by determining which techniques and visualizations are most appropriate for different situations and why. Various software solutions can produce numerous visualizations of the same data set. However, data visualization encompasses a wide range of visual configurations that depend on factors such as the type of data being displayed, the different displays (e.g., scatter plots, line graphs, and pie charts), the visual components used to represent the data (e.g., lines, dots, and bars), and the specific visual attributes of those components (e.g., color, shape, size, and length). A similar problem arises when designing data tables, where the dimensionality of the data and its complexity influence the choice of the most appropriate structure (e.g., unidirectional, bidirectional). Often, this broad spectrum of configurations requires a visualization expert who knows which techniques are best for which type of data source and what is to be conveyed. Typically, researchers and developers lack knowledge of data visualization best practices and must learn the design principles that enable effective communication and the technical details of the specific software tool they use to generate visualizations. This paper proposes a software product line approach to model and realize the variability of the visualization design process, using feature models to encode knowledge about design best practices in graphs and charts. Our approach involves solving visualization design variability through a stepwise configuration process and evaluating the proposal for a specific software visualization tool. Our solution facilitates effective communication of quantitative results by helping researchers and developers select and generate the most effective visualizations for each case. This approach opens up new opportunities for research at the intersection of data visualization and variability.

Variability Management in Self-Adaptive Systems through Deep Learning: A Dynamic Software Product Line Approach

Self-adaptive systems can autonomously adjust their behavior in response to environmental changes. Nowadays, not only can these systems be engineered individually, but they can also be conceived as members of a family based on the approach of dynamic software product lines. Through systematic mapping, we build on the identified gaps in the variability management of self-adaptive systems; we propose a framework that improves the adaptive capability of self-adaptive systems through feature model generation, variation point generation, the selection of a variation point, and runtime variability management using deep learning and the monitor–analysis–plan–execute–knowledge (MAPE-K) control loop. We compute the permutation of domain features and obtain all the possible variation points that a feature model can possess. After identifying variation points, we obtain an adaptation rule for each variation point of the corresponding product line through a two-stage training of an artificial neural network. To evaluate our proposal, we developed a test case in the context of an air quality-based activity recommender system, in which we generated 11 features and 32 possible variations. The results obtained with the proof of concept show that it is possible to manage identifying new variation points at runtime using deep learning. Future research will employ generating and building variation points using artificial intelligence techniques.

A reference model for software product line capability assessment

AbstractThe 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.

Providing command and control agility: A software product line approach

Command and Control (C2) is a broad concept that encompasses the coordination of individuals and organizations towards achieving a goal. However, dynamic and uncertain scenarios, such as military and disaster relief operations, present an inherent challenge to C2 activities. In such situations, plans often need to be changed in the face of unforeseen problems, and even coordination processes may be subject to variation. This dynamism increases the complexity of resource management and requires C2 Agility—i.e., the ability to respond to change in a timely and suitable fashion. Nonetheless, there is a lack of solutions to provide C2 Agility to cope with dynamic contexts. To address this problem, this work proposes a computational model of C2 Agility for a team of autonomous agents. This model describes how to combine reconfiguration of individual team members and of coordination approaches to adapt to context changes. The proposed approach leverages a typed-parameterized extension of a channel system to define the coordinating roles and responsibilities of team members. Each member is modeled as a dynamic software product line, with the inherent ability to reconfigure itself. To assess this model, a team of Unmanned Aerial Vehicles (UAV) performing a reconnaissance mission was simulated. The simulation showed that the proposed model was suitable for dealing with dynamic contexts. Particularly, metrics for the agile approach suggest improved system resilience in the face of induced perturbations, compared to non-agile C2. The obtained results with the proposed software-based simulations showed that the proposed model is useful in providing C2 Agility to the studied scenarios, making the behavior of the entities specified in the model capable of dealing with context changes.

Incremental Testing in Software Product Lines—An Event Based Approach

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.

Combining multiple granularity variability in a software product line approach for web engineering

Web engineering involves managing a high diversity of artifacts implemented in different languages and with different levels of granularity. Technological companies usually implement variable artifacts of Software Product Lines (SPLs) using annotations, being reluctant to adopt hybrid, often complex, approaches combining composition and annotations despite their benefits. This paper proposes a combined approach to support fine and coarse-grained variability for web artifacts. The proposal allows web developers to continue using annotations to handle fine-grained variability for those artifacts whose variability is very difficult to implement with a composition-based approach, but obtaining the advantages of the composition-based approach for the coarse-grained variable artifacts. A combined approach based on feature modeling that integrates annotations into a generic composition-based approach. We propose the definition of compositional and annotative variation points with custom-defined semantics, which is resolved by a scaffolding-based derivation engine. The approach is evaluated on a real-world web-based SPL by applying a set of variability metrics, as well as discussing its quality criteria in comparison with annotations, compositional, and combined existing approaches. Our approach effectively handles both fine and coarse-grained variability. The mapping between the feature model and the web artifacts promotes the traceability of the features and the uniformity of the variation points regardless of the granularity of the web artifacts. Using well-known techniques of SPLs from an architectural point of view, such as feature modeling, can improve the design and maintenance of variable web artifacts without the need of introducing complex approaches for implementing the underlying variability.

Static data-flow analysis for software product lines in C

Many critical codebases are written in C, and most of them use preprocessor directives to encode variability, effectively encoding software product lines. These preprocessor directives, however, challenge any static code analysis. SPLlift, a previously presented approach for analyzing software product lines, is limited to Java programs that use a rather simple feature encoding and to analysis problems with a finite and ideally small domain. Other approaches that allow the analysis of real-world C software product lines use special-purpose analyses, preventing the reuse of existing analysis infrastructures and ignoring the progress made by the static analysis community. This work presents VarAlyzer, a novel static analysis approach for software product lines. VarAlyzer first transforms preprocessor constructs to plain C while preserving their variability and semantics. It then solves any given distributive analysis problem on transformed product lines in a variability-aware manner. VarAlyzer ’s analysis results are annotated with feature constraints that encode in which configurations each result holds. Our experiments with 95 compilation units of OpenSSL show that applying VarAlyzer enables one to conduct inter-procedural, flow-, field- and context-sensitive data-flow analyses on entire product lines for the first time, outperforming the product-based approach for highly-configurable systems.

RuVa: A Runtime Software Variability Algorithm

Context-aware and smart systems that require runtime reconfiguration to cope with changes in the environment increasingly demand variability management mechanisms that can address runtime concerns. In recent years, we have witnessed new dynamic variability solutions using dynamic software product line (DSPL) approaches. However, while few solutions proposed so far have addressed the need to add, change and remove variants dynamically, none of them provide a way to check the constraints between features at runtime. Because all SAT solvers perform variability constraint checking in off-line mode, we suggest in this ongoing research paper the integration of RuVa, a runtime variability algorithm, with the FaMa tool suite to check feature constraints dynamically before a new feature is added or an existing feature is removed. This research suggests a novel approach to modifying the variability model of context-aware systems dynamically and check the feature constraints on the fly.We integrate our solution with a SAT solver that can be invoked at runtime by a cyber-physical system.We validate the effectiveness and performance of the proposed algorithm using simulations.We also provide a proof-of-concept for updating the configuration of a robot’s variability model based on contextual changes.

Energy-Efficient Deployment of IoT Applications in Edge-Based Infrastructures: A Software Product Line Approach

In order to lower latency and reduce energy consumption, edge computing proposes offloading some computation-intensive tasks usually performed in the cloud onto nearby devices in the frontier/edge of the access networks. However, the current task offloading approaches are often quite simple. They neither consider the high diversity of hardware and software technologies present in edge network devices nor take into account that some tasks may require some specific software and hardware infrastructure to be executed. This article proposes a task offloading process that leans on software product line technologies, which are a very good option to model the variability of software and hardware present in edge environments. First, our approach automates the separation of application tasks, considering the data and operation needs and restrictions among them, and identifying the hardware and software resources required by each task. Second, our approach models and manages separately the infrastructure available for task offloading, as a set of nodes that provide certain hardware and software resources. This separation allows to reason about alternative offloading of tasks with different hardware and software resource requirements, in heterogeneous nodes and minimizing energy consumption. In addition, the offloading process considers alternative implementations of tasks to choose the one that best fits the hardware and software characteristics of the available edge network infrastructure. The experimental results show that our approach reduces the energy consumption in the user node by approximately 41%–62%, and the energy consumption of the devices involved in a task offloading solution by 34%–48%.

Survey Evaluation of an Approach for Dynamic Software Product Lines

In Dynamic Software Product Lines (DSPLs) product configuration occurs at runtime. Modelling variability and configuring the product in DSPLs should consider the context and non-functional requirements (NFRs) satisfaction. ConG4DaS (Contextual Goal models For Dynamic Software product lines) is a Requirements Engineering (RE) approach for DSPL which supports (i) modelling of variability with goals, NFRs, contexts and the relationship be-tween them; and (ii) offers a product configuration based on contexts, NFRs and their priority and interactions. In this paper, we present a survey evaluation of ConG4DaS with RE and DSPL researchers in regard to the perceived usefulness. In the survey, both RE and DSPL researchers perceived ConG4DaS as useful for modelling and configuring DSPLs. However, the RE group gave more positive answers than the DSPL group.

Reparation in Evolutionary Algorithms for Multi-objective Feature Selection in Large Software Product Lines

Software Product Lines Engineering is the area of software engineering that aims to systematise the modelling, creation and improvement of groups of interconnected software systems by formally expressing possible alternative products in the form of Feature Models. Deriving a software product/system from a feature model is called Feature Configuration. Engineers select the subset of features (software components) from a feature model that suits their needs, while respecting the underlying relationships/constraints of the system–which is challenging on its own. Since there exist several (and often antagonistic) perspectives on which the quality of software could be assessed, the problem is even more challenging as it becomes a multi-objective optimisation problem. Current multi-objective feature selection in software product line approaches (e.g., SATIBEA) combine the scalability of a genetic algorithm (IBEA) with a solution reparation approach based on a SAT solver or one of its derivatives. In this paper, we propose MILPIBEA, a novel hybrid algorithm which combines IBEA with the accuracy of a mixed-integer linear programming (MILP) reparation. We show that the MILP reparation modifies fewer features from the original infeasible solutions than the SAT reparation and in a shorter time. We also demonstrate that MILPIBEA outperforms SATIBEA on average on various multi-objective performance metrics, especially on the largest feature models. The other major challenge in software engineering in general and in software product lines, in particular, is evolution. While the change in software components is common in the software engineering industry, the particular case of multi-objective optimisation of evolving software product lines is not well-tackled yet. We show that MILPIBEA is not only able to better take advantage of the evolution than SATIBEA, but it is also the one that continues to improve the quality of the solutions when SATIBEA stagnates. Overall, IBEA performs better when combined with MILP instead of SAT reparation when optimising the multi-objective feature selection in large and evolving software product lines.

Aspect Multiple Product Lines

Software product line (SPL) approach has known a great attention in the software field due to the advantages it brings to software-development. In some large fields having a single SPL is no longer sufficient to manage variability. Several separated SPLs rise then resulting in what is known by multiple product lines (MPL). However, the adoption of an MPL results in several challenges namely: managing reuse between SPLs, MPL model complexity and distributed-derivation. In this paper, we present a new methodology for MPLs engineering called AMPL. Our approach helps managing reuse across MPLs basing on two key concepts: separation of concerns and partial derivation. AMPL approach is validated in the context of an e-government MPL and its various steps are illustrated along the paper. The results show that our approach helps systemising reuse within MPLs and structuring the MPL model. Moreover, SPLs are integrated early in the development process thus avoiding the distributed-derivation challenges.

An empirical study of performance using Clone & Own and Software Product Lines in an industrial context

Clone and Own (CaO) is a widespread approach to generate new software products from existing software products by adding small changes. The Software Product Line (SPL) approach addresses the development of families of products with similar features, moving away from the production of isolated products. Despite the popularity of both approaches, no experiment has yet compared them directly.

AMPL: aspect multiple product lines

The Software Product Line approach is well-known for the advantages it brings to the software-development field. However, single SPLs had been found to be inadequate in managing the variability of large scale and complex software-intensive systems. For this reason, although the Multiple Software Product Lines have been proposed as another solution to tame the complexity of SPLs, the adoption of an MPL has given rise to several challenges such as facilitating the reuse between SPLs, the complexity of the model as well as distributed-derivation. In this paper, we have presented a new methodology for MPLs engineering, which is called the AMPL. Our approach had helped the reuse management of MPLs through the two key concepts of separation of concerns and partial derivation. The various steps of the AMPL approach are illustrated in this paper and were validated in the context of an e-Government MPL. Apart from the systemization of reuse within the MPLs as well as in the structuring of the MPL model, our approach on the early integration of the SPLs during the development process had also been proven to be effective in the prevention of the distributed-derivation issue.

Mobile Serious Game Design using User Experience: Modeling of Software Product Line Variability

In recent years, gamification has emerged as a new approach to increasing learner engagement. It covers a very wide range of games with very different purposes and with many fields of application. However, most of the gamification solutions proposed do not adopt the same modeling approach and little attention has been paid to mobile serious games (MSG) belonging to different pedagogical contexts. In order to overcome these difficulties, we have developed in this paper a generic model based on the Software Product Line (SPL) approach to manage the common and variable points of the MSG product set. We have also focused on the User eXperience (UX) concept to study the aspects that most affect the player’s experience in the context of MSGs. These aspects have been modeled in the form of features in the SPL Feature Model. MSG designers can use the model proposed during the development process, both to manage variability and to create an effective and fun learning environment.

A goal-driven software product line approach for evolving multi-agent systems in the Internet of Things

Multi-agent systems have proved to be a suitable technology for developing self-adaptive Internet of Things (IoT) systems, able to make the most appropriate decisions to address unexpected situations. This leads to new opportunities to use multi-agent technologies to develop all kinds of cyber–physical systems, which usually encompass a high diversity of devices (e.g., new home appliances). The heterogeneity of devices and the high diversity of the available technology, demand the explicit modeling of all kinds of variability for ultra-large systems. However, multi-agent systems lack mechanisms to effectively deal with the different degrees of variability present in these kinds of systems. Software Product Line (SPL) technologies, including variability models, have been successfully applied to different domains to explicitly model variability in hardware, system requirements or user-intended goals. In addition, current market trends are unpredictable, imposing novel technologies, new requirements and goals that must be incorporated immediately into the running systems without damaging them. In this paper, we combine goal-driven and SPL approaches to develop and drive the evolution of multi-agent systems in the context of cyber–physical systems. We propose an SPL process and an evolution process that define a set of models (iStar 2.0 for goals and CVL models for variability) and algorithms to automatically propagate changes to agents running in multiple heterogeneous devices, each of them with a different configuration. We illustrate the proposal in the context of a home energy management system. Finally, we have tested the scalability and performance of the proposal using randomly generated models. The results show that with our approach it is possible to manage huge iStar models of 10000 elements in seconds.

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.

A UI-DSPL Approach for the Development of Context-Adaptable User Interfaces

Unlike adaptive interfaces which use sensors to adapt themselves, adaptable interfaces need the intervention of end users to adapt their different aspects according to user requirements. These requirements are commonly expressed according to the context of use. This latter was defined by the triplet where the platform refers to the physical device and the device software, the environment refers to the physical environment in which the application is used and the user element refers to the user preferences and user profile. In this paper, we define a dynamic software product line (DSPL) approach for the development of a family of context-adaptable user interfaces. The DSPL paradigm exploits the knowledge acquired in software product line engineering to develop systems that can be context-aware, or runtime adaptable. Our approach satisfies a set of contributions which will be validated by implementing and evaluating them according to an illustrative case study.

Context‐dependent reconfiguration of autonomous vehicles in mixed traffic

AbstractHuman drivers naturally adapt their behaviour depending on the traffic conditions, such as the current weather and road type. Autonomous vehicles need to do the same, in a way that is both safe and efficient in traffic composed of both conventional and autonomous vehicles. In this paper, we demonstrate the applicability of a reconfigurable vehicle controller agent for autonomous vehicles that adapts the parameters of a used car‐following model at runtime, so as to maintain a high degree of traffic quality (efficiency and safety) under different weather conditions. We follow a dynamic software product line approach to model the variability of the car‐following model parameters, context changes and traffic quality, and generate specific configurations for each particular context. Under realistic conditions, autonomous vehicles have only a very local knowledge of other vehicles' variables. We investigate a distributed model predictive controller agent for autonomous vehicles to estimate their behavioural parameters at runtime, based on their available knowledge of the system. We show that autonomous vehicles with the proposed reconfigurable controller agent lead to behaviour similar to that achieved by human drivers, depending on the context.

A Dynamic Tracing Model for Agile Software Product Lines Domain Engineering from Features to Structural Elements: An Approach Based on Dynamic Routing

Even if the benefit of implementing Software Product Lines is well established, adopting such a large system is still a complex choice to make: it is hard to implement, needs a good knowledge of market growth and a clear vision of the enterprise objectives for long term. Therefore, many companies remain unwilling to adopt such an approach, unless they gain flexibility and get guarantees. Flexibility can be achieved by adopting an Agile Software Product Line approach, to make sure changes are rapidly implemented and product adapted to market evolution. Guarantees can be acquired by tracing elements and the relations between them. However, tracing in Agile Software Product Line context still needs to gain maturity as it is costly and therefore rarely adopted. In this paper, we discuss the added value of traceability for Agile Software Product Lines, and present our tracing model inspired from dynamic network routing.