Software Product Line Engineering Research Articles

Quality Improvement of Variability Management Tools in Software Product Line Engineering

Software Product Line Engineering (SPLE) is an engineering paradigm that allows the creation of software product portfolio similar to the systems or products. It is important for an effective method deployment in the particular context of industrial scale Product Lines (PLs). The purpose of this research work is to determine and gain a detailed understanding of where and how the quality of variability management tools could be improved. The study was conducted experimentally and involved 10 feature-modelling tools based on their availability and support for feature models, to be evaluated using the benchmark in order to identify whether and to what extent these tools provide support for the identified quality attributes.

Unifying Behavioral and Feature Modeling for Testing of Software Product Lines

Existing software product line (SPL) engineering testing approaches generally provide positive testing that validates the SPL’s functionality. Negative testing is commonly neglected. This research aims to unify behavioral and feature models of an SPL, enable testing before and after variability binding for domain-centric and product-centric testing, and combine positive and negative testing for a holistic testing view. This study suggests behavioral modeling with event sequence graphs (ESGs). This heterogeneous modeling strategy supports bottom-up domain testing and top-down product testing with the feature model. This new feature-oriented ESG test creation method generates shorter test sequences than the original ESG optimum test sequences. Statechart and original ESG test-generating methods are compared. Positive testing findings are similar. The Statechart technique generated 12 test cases with 59 events, whereas the ESG technique created six test cases with 60 events. The ESG technique generated 205 negative test cases with 858 events with the Test Suite Designer tool. However, the Conformiq Designer tool for the Statechart technique does not have a negative test case generation capability. It is shown that the proposed ESG-based holistic approach confirms not only the desirable (positive) properties but also the undesirable (negative) ones. As an additional research, the traditional ESG test-generating approach is compared to the new feature-oriented method on six SPLs of different sizes and features. Our case study results show that the traditional ESG test generation approach demonstrated higher positive test generation scores compare to the proposed feature-oriented test generation approach. However, our proposed feature-oriented test generation approach is capable of generating shorter test sequences, which could be beneficial for reducing the execution time of test cases compared to traditional ESG approach. Finally, our case study has also shown that regardless of the test generation approach, there has been found no significant difference between the Bottom-up and Top-down test strategies with respect to their positive test generation scores.

: Software product lines extraction driven by language server protocol

Software product lines (SPL) describe highly-variable software systems as a family of similar products that differ in terms of the features they provide. The promise of SPL engineering is to enable massive software reuse by allowing software features to be reused across a variety of different products made for several customers. However, there are some disadvantages in the extraction of SPLs from standard applications. Most notably, approaches to the development of SPLs are not supported by the base language and use a syntax and composition techniques that require a deep understanding of the tools being used. Therefore, the same features cannot be used in a different application and developers must face a steep learning curve when developing SPLs for the first time or when switching from one approach to a different one. Ultimately, this problem is due to a lack of standards in the area of SPL engineering and in the way SPLs are extracted from variability-unaware applications. In this work, we present a framework based on LSP and dubbed ▪ that aims at standardizing such a process by decoupling the refactoring operations made by the user from the effect they have on the source code. This way, the server for a specific SPL development approach can be used across several development environments that provide clients with customized refactoring options. Conversely, the developers can use the same client to refactor SPLs made according to different approaches without needing to learn the syntax of each approach. To showcase the applicability of the approach, we present an evaluation performed by refactoring four SPLs according to two different approaches: the results show that a minimal implementation of the ▪ client and server applications can be used to reduce the effort of extracting an SPL up to the 93% and that it can greatly reduce or even completely hide the implementation details from the developer, depending on the chosen approach.

Agile Software Development and Reuse Approach with Scrum and Software Product Line Engineering

Agile methods and software product line engineering (SPLE) are widely recognized as practical approaches for delivering high-quality software, adapting to evolving stakeholder needs, and tackling complex problems. This study proposes a hybrid agile software development and reuse approach called SPLE-Scrum based on the activities of software product line engineering and Scrum. Within the SPLE process, we incorporate requirement engineering and design practices to create a reference architecture with reusable components called core assets by introducing a product management meeting. The core assets are reused to build a series of applications with various product lines. The product increments are delivered in each Sprint with the review and retrospective meetings based on Scrum lifecycle and practices. We present a case study involving a blockchain online store to demonstrate the practical application of SPLE-Scrum, highlighting the benefits of integrating Scrum and software product line engineering. The research hypotheses of the proposed approach were validated through a study of structured interviews with 5 experts and 44 software practitioners, showing that the key factors of product management, project requirements, and product architecture in the SPLE-Scrum approach have a beneficial impact on project success. The SPLE-Scrum approach provides valuable insights and practical guidance for organizations seeking to optimize their software engineering practices while incorporating agile development and software reuse capabilities.

Software system architecture based on the concept of reflexive adaptation

The conducted research substantiates the relevance of the application and the need to develop adaptive software to solve the problems of using IT in the construction industry. The basic principles of reflexive adaptation, as well as the use of software product lines engineering (SPLE) technology to create adaptive software systems, are considered. A generalized architecture of an adaptive software system based on models of variability and levels of reflection is proposed. A formal description of the reflexive software system for the implementation of variants of the adaptive behavior of application programs has been carried out. The practical significance of the research is that giving the applied software system adaptive properties will enable it to modify its structure at a qualitatively new level, which in turn will increase its reliability, resistance to failures, flexibility, reduce the cost of maintenance and extend the life of the system. Such a system will be able to expand the class of solvable tasks throughout the entire life cycle, as well as perform operations that are currently considered part of the duties of certain specialists, for example, it will be able to perform self-administration functions.

A benchmark generator framework for evolving variant-rich software

Software often needs to exist in different variants, which account for varying customer requirements, environments, or non-functional aspects, such as energy consumption. Unfortunately, the number of variants can grow exponentially with the number of features. As such, developing and evolving variant-rich systems is challenging, since they do not only evolve “in time” as single systems, but also “in space” with new variants. Fortunately, many different methods and tools for variant-rich systems have been proposed over the last decades, especially in the field of software product line engineering. However, their level of evaluation varies significantly, threatening their relevance for practitioners and that of future research. Many tools have only been evaluated on ad hoc datasets, minimal examples, or unrealistic and limited evolution scenarios, missing large parts of the actual evolution lifecycle of variant-rich systems.Our long-term goal is to provide benchmarks to increase the maturity of evaluation of methods and tools for evolving variant-rich systems. However, providing manually curated and sufficiently detailed benchmarks that cover the whole evolution lifecycle of variant-rich systems is challenging. We present the framework vpbench, which simulates the evolution of a variant-rich system and thereby generates an evolution enriched with metadata explaining the evolution. The generated benchmarks, i.e., the evolution histories and metadata, can serve as ground truth to check the results of tools applied on it. We formalize the claims we make about the generator and the generated benchmarks as requirements. The design of vpbench comprises modular generators and evolution operators that automatically evolve real codebases. We implement simple and advanced evolution operators—e.g., relying on code transplantation to incorporate features from real projects. We demonstrate how vpbench addresses its claimed requirements, also considering multiple degrees of realism, extensibility and language-independence of the generated benchmarks.

A Reference Framework for Variability Management of Software Product Lines

Variability management (VM) in software product line engineering (SPLE) is introduced as an abstraction that enables the reuse and customization of assets. VM is a complex task involving the identification, representation, and instantiation of variability for specific products, as well as the evolution of variability itself. This work presents a comparison and contrast between existing VM approaches using “qualitative meta-synthesis” to determine the underlying perspectives, metaphors, and concepts of existing methods. A common frame of reference for the VM was proposed as the result of this analysis. Putting metaphors in the context of the dimensions in which variability occurs and identifying its key concepts provides a better understanding of its management and enables several analyses and evaluation opportunities. Finally, the proposed framework was evaluated using a qualitative study approach. The results of the evaluation phase suggest that the organizations in practice only focus on one dimension. The presented frame of reference will help the organization to cover this gap in practice.

Projectional Editing of Software Product Lines Using Multi-variant Model Editors

Model-driven software engineering (MDSE) as well as software product line engineering (SPLE) achieve productivity gains by raising the level of abstraction and fostering organized reuse. Consequently, the integrating discipline model-driven software product line engineering (MDSPLE) aims at combining the best of both worlds by creating multi-variant models which are (automatically) configured into single-variant models which are in turn adapted further (if required). Inherently complex multi-variant models call for urgently needed tools providing support for editing multi-variant models. In this paper, we present a framework for projectional multi-variant editors which make complexity manageable using a user-friendly representation. At all times, a domain engineer is aware of editing a multi-variant model which is necessary to assess the impact of changes on all model variants. Supporting a clear separation of product space (domain model) and variant space (variability annotations), our projectional multi-variant editors provide a novel approach to representing variability information which is displayed non-intrusively. Furthermore, the domain engineer may employ a projectional multi-variant editor to adapt the representation of the multi-variant domain model in a flexible way, according to the current focus of interest.

A DSPL and Reinforcement Learning Approach for Context-Aware IoT Systems Development

The internet of things is a paradigm of interconnected devices able to communicate and exchange information to achieve users' requirements. In spite of their expansion in the last years, IoT systems still face challenges that hinder gaining major advantages from them. One of these challenges is to automatically adapt the system to the user's context and preferences. As a proposition to deal with this problem, this paper presents a methodology to design and develop IoT systems that adapt their behavior to their context, which can be a user or environmental context. This methodology is based on dynamic software product line engineering and uses Markov process to design the adaptation plan of the system and a reinforcement learning algorithm to implement it.

E-Business Software Product Line Methodology Based on SMEs Characteristics

The growth of Small and Medium Enterprises (SMEs) will certainly have a positive influence on economic development in a country. However, many SMEs struggle to survive, grow, and show limited productivity. It was recorded that there were around 63.9% of SMEs in Indonesia whose turnover had decreased by more than 30% during the COVID-19 pandemic. Among the factors that cause the low survival rate of SMEs, a factor that is considered critical is the lack of success in the use of e-business. The use of e-business by SMEs is not a one-size-fits-all solution, because SMEs have various characteristics. In this study, an E-Business Software Product Line Methodology based on SMEs characteristics was proposed using Software Product Line Engineering (SPLE) approach. In general, the proposed methodology was sufficient to describe the aspects needed in building a software development methodology. Aspects that had not been described were those related to software project management. The proposed methodology is useful for building an e-business application platform that can be customized based on SMEs characteristics.

UML Transformation to Java-based Software Product Lines

Software product line engineering (SPLE) is an emerging approach that enables variability management in software development. SPLE offers tremendous benefits, but lack of tool support becomes a barrier in the adoption of SPLE. Variability modules for Java (VMJ) is an implementation approach that is defined based on the variability modules (VM) concept to support SPLE. VMJ combines Java modules system and design patterns that are commonly used by software developers. VMJ is accompanied by a UML profile, called UML-VM profile, which extends UML notation to model variability in the UML diagram. UML-VM diagram is used to model the problem domain, and VMJ is used in the domain implementation. In this research, we design a model transformation from Unified Modeling Language (UML) diagram into VMJ. The transformation rules are defined based on the UML-VM profile and implemented in the Eclipse Acceleo model to text transformation. As a result, a UML diagram can be transformed automatically into Java-based software product lines. The transformation tool is evaluated using a case study by comparing the generated code and the actual implementation.

Towards Erlang-based ABS Microservices Framework for Software Product Line Development

The current widely used software system can be categorised as a large or very large decentralised control system with various requirements and continuous interchangeable elements. This characteristic leads to a need to control the variability to manage such systems. Software Product Line Engineering (SPLE) is one of the approaches that can manage the variability by developing sets of products. However, there is a need for support tools for development with software product line engineering. One language that supports the SPLE process is Abstract Behavioral Specification (ABS). Some SPLE research has used ABS to create frameworks that support the SPLE process. ABS Microservices is one research that utilises ABS to create a web framework that supports the SPLE process. This framework uses ABS to generate Java-based applications. The research interest in the web application is driven by the fact that it is one of the software types widely used by organisations and serves as the primary support of their business. Microservices are highly interoperable, thus enabling researchers to integrate different technology from other research. However, there is a need for renewal to the ABS Microservices framework. There is a need for more variants of SPLE-enabled frameworks that use more programming language as a specific programming language has its strength and weakness. Deprecation of the Java backend of the ABS opens a new exploration of another web framework that uses other ABS backend languages. We present the ABS microservices web framework based on Erlang OTP. We choose Erlang because it promises more efficient resource usage and the Erlang backend is one of the ABS backends with the most available features. This research aims to create an entry point for ABS Microservices to support more language. This research shows that the Erlang variant of ABS Microservices has less resource usage than the Java variant. Hence, this promises more options to develop product lines using ABS Microservices.

Practical Experience Applying Feature‐based Product Line Engineering in a DevOps Environment: Achieving the Best of Both Worlds

AbstractSystems and Software Product Line Engineering (PLE) is an engineering discipline to produce and maintain a family of similar products in an efficient manner. It has long been known that managing a product portfolio as a single entity, as opposed to a multitude of separate products, can bring substantial improvements in schedule, cost, and quality. DevOps is an engineering discipline, practiced within an infrastructure of test and deployment automation, that seeks to minimize the time that a change to a product is made, and the product is built, validated, deployed, and made available to the end users. Many organizations find themselves willing to employ both disciplines – that is, to employ DevOps for products in a product line. This paper shows how that can be done, relates a case where it was done, and reports on the substantial benefits that were realized.

Empirical analysis of the tool support for software product lines

For the last ten years, software product line (SPL) tool developers have been facing the implementation of different variability requirements and the support of SPL engineering activities demanded by emergent domains. Despite systematic literature reviews identifying the main characteristics of existing tools and the SPL activities they support, these reviews do not always help to understand if such tools provide what complex variability projects demand. This paper presents an empirical research in which we evaluate the degree of maturity of existing SPL tools focusing on their support of variability modeling characteristics and SPL engineering activities required by current application domains. We first identify the characteristics and activities that are essential for the development of SPLs by analyzing a selected sample of case studies chosen from application domains with high variability. Second, we conduct an exploratory study to analyze whether the existing tools support those characteristics and activities. We conclude that, with the current tool support, it is possible to develop a basic SPL approach. But we have also found out that these tools present several limitations when dealing with complex variability requirements demanded by emergent application domains, such as non-Boolean features or large configuration spaces. Additionally, we identify the necessity for an integrated approach with appropriate tool support to completely cover all the activities and phases of SPL engineering. To mitigate this problem, we propose different road map using the existing tools to partially or entirely support SPL engineering activities, from variability modeling to product derivation.

A conceptual model for unifying variability in space and time: Rationale, validation, and illustrative applications

With the increasing demand for customized systems and rapidly evolving technology, software engineering faces many challenges. A particular challenge is the development and maintenance of systems that are highly variable both in space (concurrent variations of the system at one point in time) and time (sequential variations of the system, due to its evolution). Recent research aims to address this challenge by managing variability in space and time simultaneously. However, this research originates from two different areas, software product line engineering and software configuration management, resulting in non-uniform terminologies and a varying understanding of concepts. These problems hamper the communication and understanding of involved concepts, as well as the development of techniques that unify variability in space and time. To tackle these problems, we performed an iterative, expert-driven analysis of existing tools from both research areas to derive a conceptual model that integrates and unifies concepts of both dimensions of variability. In this article, we first explain the construction process and present the resulting conceptual model. We validate the model and discuss its coverage and granularity with respect to established concepts of variability in space and time. Furthermore, we perform a formal concept analysis to discuss the commonalities and differences among the tools we considered. Finally, we show illustrative applications to explain how the conceptual model can be used in practice to derive conforming tools. The conceptual model unifies concepts and relations used in software product line engineering and software configuration management, provides a unified terminology and common ground for researchers and developers for comparing their works, clarifies communication, and prevents redundant developments.

Reducing Redundant Test Executions in Software Product Line Testing—A Case Study

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.

Towards a component-based system model to improve the quality of highly configurable systems.

Due to ever-evolving software developments processes, companies are motivated to develop desired quality products quickly and effectively. Industries are now focusing on the delivery of configurable systems to provide several services to a wide range of customers by making different configurations in a single largest system. Nowadays, component-based systems are highly demanded due to their capability of reusability and restructuring of existing components to develop new systems. Moreover, product line engineering is the major branch of the component-based system for developing a series of systems. Software product line engineering (SPLE) provides the ability to design several software modifications according to customer needs in a cost-effective manner. Researchers are trying to tailor the software product line (SPL) process that integrates agile development technologies to overcome the issues faced during the execution of the SPL process such as delay in product delivery, restriction to requirements change, and exhaustive initial planning. The selection of suitable components, the need for documentation, and tracing back the user requirements in the agile-integrated product line (APL) models still need to improve. Furthermore, configurable systems demand the selected features to be the least dependent. In this paper, a hybrid APL model, quality enhanced application product line engineering (QeAPLE) is proposed that provides support for highly configurable systems (HCS) by evaluating the dependency of features before making the final selection. It also has a documentation and requirement traceability function to ensure that the product meets the desired quality. Two-fold assessments are undertaken to validate the suggested model, with the proposed model being deployed on an active project. After that, we evaluated the proposed model performance and effectiveness using after implementing it in a real-world environment and compared the results with an existing method using statistical analysis. The results of the experimental study proofs that the proposed model is practically and statistically significant as compared to the existing method in terms of effectiveness and participants’ performance. Hence, the statistical results of the comparative analysis show that the proposed model improved ease of understanding and adaptability, required effort, high-quality achievement, and version management are significant i.e., more the 50% as compared to the exiting method i.e., less than 50%. The proposed model offers to assist in the development of a highly configurable system that achieves the needed quality. Therefore, the proposed model manages the variation identification, versions control, components dependency for correct selection of components, and validation activities from domain engineering to application engineering.

Realizing self-adaptive systems via online reinforcement learning and feature-model-guided exploration

AbstractA self-adaptive system can automatically maintain its quality requirements in the presence of dynamic environment changes. Developing a self-adaptive system may be difficult due to design time uncertainty; e.g., anticipating all potential environment changes at design time is in most cases infeasible. To realize self-adaptive systems in the presence of design time uncertainty, online machine learning, i.e., machine learning at runtime, is increasingly used. In particular, online reinforcement learning is proposed, which learns suitable adaptation actions through interactions with the environment at runtime. To learn about its environment, online reinforcement learning has to select actions that were not selected before, which is known as exploration. How exploration happens impacts the performance of the learning process. We focus on two problems related to how adaptation actions are explored. First, existing solutions randomly explore adaptation actions and thus may exhibit slow learning if there are many possible adaptation actions. Second, they are unaware of system evolution, and thus may explore new adaptation actions introduced during evolution rather late. We propose novel exploration strategies that use feature models (from software product line engineering) to guide exploration in the presence of many adaptation actions and system evolution. Experimental results for two realistic self-adaptive systems indicate an average speed-up of the learning process of 33.7% in the presence of many adaptation actions, and of 50.6% in the presence of evolution.

A concrete product derivation in software product line engineering: a practical approach

A concrete product derivation in software product line engineering: a practical approach

A concrete product derivation in software product line engineering: a practical approach

A concrete product derivation in software product line engineering: a practical approach