Product Line Engineering Research Articles

A Context-Based Perspective on Frost Analysis in Reuse-Oriented Big Data-System Developments

The large amount of available data, generated every second via sensors, social networks, organizations, and so on, has generated new lines of research that involve novel methods, techniques, resources, and/or technologies. The development of big data systems (BDSs) can be approached from different perspectives, all of them useful, depending on the objectives pursued. In particular, in this work, we address BDSs in the area of software engineering, contributing to the generation of novel methodologies and techniques for software reuse. In this article, we propose a methodology to develop reusable BDSs by mirroring activities from software product line engineering. This means that the process of building BDSs is approached by analyzing the variety of domain features and modeling them as a family of related assets. The contextual perspective of the proposal, along with its supporting tool, is introduced through a case study in the agrometeorology domain. The characterization of variables for frost analysis exemplifies the importance of identifying variety, as well as the possibility of reusing previous analyses adjusted to the profile of each case. In addition to showing interesting findings from the case, we also exemplify our concept of context variety, which is a core element in modeling reusable BDSs.

Portfolio Evolution Analysis for SPL Scoping: Unveiling the dynamics with dedicated time-series dashboards

Software Product Line Engineering (SPLE) is a recognized methodology for systematically developing reusable software components and tailored software products for specific market segments. A critical activity within domain engineering is SPL Scoping, aimed at profiling the SPL boundaries and fitting this market segment. Yet, this market is a moving target, which requires SPLs to be proactive in anticipating and addressing future challenges and opportunities. In this setting, rather than all the possible products potentially derived from the SPL’s Feature Model (i.e., the potential portfolio), the subset of products actually deployed is a better indicator of market adoption and customer preferences, and ultimately, of the SPL’s fitness to the market. This study characterizes the phenomenon of ‘deployed portfolio evolution’ in terms of the size and frequency of portfolio changes. We then elaborate on the advantages of utilizing this data source and the necessity for dedicated tools for Portfolio Evolution Analysis integrated within variability managers. To achieve this, we introduce the functional requirements, implementation, and architecture of PortfolioScan, a dashboard for Portfolio Evolution Analysis built on top of pure::variants. The dashboard enables the evaluation of feature usage through time-series charts such as temporal heat maps, line charts, and also a scoping-criteria comparison matrix. Evaluation results (n=13) indicate a positive perception. Practitioners also recognize the benefits of Portfolio Evolution Analysis for Testing Resource Optimization and Configuration Assistance. The ultimate goal of the study is to establish a basis for more responsive and market-oriented decision-making in SPL tasks.

Identifying Reusable Core Assets of Digital Health Apps.

We aim to identify and model reusable core assets to facilitate the development of a number of similar, but adapted DHAs in the context of an initial product line engineering approach. To identify core assets, we apply a systematic analysis of six exemplary state-of-the-art DHAs. In an iterative process, they were modeled in a feature model. We identified 14 core assets of DHAs out of which six are mandatory (i.e. required by each DHA) and eight are optional core assets (i.e. required by most DHAs, depending on the app complexity). We found that DHAs share common functionalities that could contribute to a more efficient development of the DHA, especially in terms of time and cost savings.

Software Update Methodologies for Feature-Based Product Lines: A Combined Design Approach

The automotive industry is experiencing a significant shift, transitioning from traditional hardware-centric systems to more advanced software-defined architectures. This change is enabling enhanced autonomy, connectivity, safety, and improved in-vehicle experiences. Service-oriented architecture is crucial for achieving software-defined vehicles and creating new business opportunities for original equipment manufacturers. A software update approach that is rich in variability and based on a Merkle tree approach is proposed for new vehicle architecture requirements. Given the complexity of software updates in vehicles, particularly when dealing with multiple distributed electronic control units, this software-centric approach can be optimized to handle various architectures and configurations, ensuring consistency across all platforms. In this paper, our software update approach is expanded to cover the solution space of the feature-based product line engineering, and we show how to combine our approach with product line engineering in creative and unique ways to form a software-defined vehicle modular architecture. Then, we offer insights into the design of the Merkle trees utilized in our approach, emphasizing the relationship among the software modules, with a focus on their impact on software update performance. This approach streamlines the software update process and ensures that the safety as well as the security of the vehicle are continuously maintained.

A Configuration Management Strategy for Modelbased Product Line Engineering in Aircraft Systems Development

AbstractAircraft systems development is complex and time‐consuming. Model‐based Product Line Engineering (MBPLE) aims to reuse assets between projects to accelerate the development of systems at their early stage. Despite guidance from standards, MBPLE practitioners still face the challenge of deploying an appropriate configuration management strategy. This paper presents and demonstrates a configuration management strategy to support practitioners deploying MBPLE for aircraft systems development. We developed this strategy to comply with ISO/IEC 26580 and address pending standard ambiguities using best practices from product lines for systems, software, business processes, and systems of systems. The proposed strategy supports long‐term product line evolution, management of different asset types, and independent product environments.

Code Generator Development to Transform IFML (Interaction Flow Modelling Language) into a React-based User Interface

Model-Driven Software Engineering (MDSE) is a software development approach that uses the Model to be the main actor of the development. MDSE can be applied to User Interface (UI) Development so that a model for the UI can be built, and then a transformation can be made to turn it into a running application. In this research, we develop UI Generator to support UI Development with the MDSE approach. This UI Generator can also support UI Development in Software Product Line Engineering (SPLE) paradigm. The UI is modeled with Interaction Flow Modeling Language (IFML) diagram. Then The IFML diagram is transformed into React-Based UI by the UI Generator. The UI Generator is developed with Acceleo on Eclipse IDE to transform IFML into React Code with the transformation rules defined in this research. The UI generator is also enriched with display settings and static page management to address user customization needs. The experimental results show that the UI Generator can generate a functional website. Besides evaluating the working product, UI Generator is evaluated qualitatively well based on six quality criteria as an SPLE supporting tool.

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.

A Product-Line-Engineering Framework for Secure Enterprise-Resource-Planning Systems

Enterprise-resource-planning (ERP) systems are highly complex, incorporating critical data and configuration options that can easily cause security threats or risks. While product-line engineering (PLE) provides methods for dealing with configurability, security concerns are not of primary concern in established PLE frameworks. In this paper, we extend the perspectives of established PLE frameworks to incorporate security engineering for ERP systems. We build on a literature review of 15 years (2008-2022) of research on security engineering for ERP systems or product lines. Our framework incorporates three perspectives (i.e., application, security, and domain engineering) with 16 processes and 24 activities. We discuss our framework with respect to the ERP reference architecture and relevant security concerns. Our contributions are intended to help researchers and practitioners obtain a reference on how security engineering can be integrated into PLE for ERP systems.

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.

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.

Variability on System Architecture using Airbus MBPLE for MOFLT Framework

AbstractModel‐Based Product Line Engineering (MBPLE) and Variability Management are key enablers of Model‐Based Systems Engineering (MBSE). A MBSE Architecture Framework based on the SysML language has been developed at Airbus Group Level: R‐MOFLT ‐ Requirements, Mission, Operational, Functional, Logical, Technical Analysis. MBPLE4MOFLT is a feature‐based product line engineering framework based on the ISO 26580 (2021) standard, extending R‐MOFLT. This paper defines the methodological foundations of the Airbus MBPLE4MOFLT framework and provides insights into its application in practice.

Modeling System Configurations Over Time

AbstractOne of the most troublesome and challenging parts of systems engineering is that systems keep changing. Some changes are planned as part of a phased system rollout. Others can occur because of changes in the environment, technology, customer need, unexpected emergent properties, competition, discovered system vulnerabilities, etc. Regardless of why, the systems engineer needs to document these configurations as part of a digital thread leading to physical systems that will be manufactured and installed. When using SysML as part of MBSE, there are advantages and disadvantages regarding the modeling variability using inheritance and other structural modeling techniques. Elements in a so‐called superclass will be inherited by all members. This is advantageous for additive systems but can cause issues when configurations require removal of systems. This paper will examine system configuration over time showing how to model configurations and changes. It will also look at other techniques such as Product Line Engineering (PLE) with OVM and Feature Based Modeling.

TOWARDS A CONFIGURATION MANAGEMENT INTEGRATION TO FEATURE MODELS IN MODEL-BASED PRODUCT LINE ENGINEERING

AbstractIn parallel with the industry 4.0 revolution, customers’ demand and number of product requirements are increasing, inducing increased product variability. System complexity is growing with the new technologies and system architectures. Hence, maintaining a system consistent and in the desired state becomes crucial. This paper tackles two problems: a product's variability and its temporal evolution. Regarding variability, Model Based Systems Engineering (MBSE) methods and Product Line Engineering (PLE) techniques become essential to configuring products by selecting and arranging features in a combination. In parallel, versioning and temporal evolution are managed with the configuration management (CM) principles. A versioned feature model (FM) is proposed. In PLE methodology, the first step is to model variability through traditional FM. This research presents an extension of the FM by integrating CM into it. The versioned FM includes not only features’ variants but also their versions, making it evolve in time. This work is presented as a base for a work that will study the application of CM for PLE. This study is done in an automotive industry context at Renault Group, and the model proposed is applied to Renault's systems.

Template-Based Generator for Single-Choice Questions

Manual composition of tasks and exams is a challenging and time-consuming task. Especially when exams are taken remotely without the personal monitoring by examiners, most exams can easily lose their integrity with the use of previously done exercises or student communication. This research introduces an approach that incorporates the principles of the generative software development and aspects of the feature-oriented product line engineering process into the field of question creation and generation. The resulting generator can be used to generate single-choice-question-families by means of written question templates. The generated questions within a question-family differ based on the set features and parameters and can be imported into the target learning management system ILIAS. Without much effort, examiners and educators can use the generator to create variants of their questions and deliver them to their students.

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.

ScrumOntoSPL: Collaborative Method of Agile Product Line Engineering for Software Resource Reuse

Agile Product Line Engineering (APLE), a relatively new approach combining the two successful methods of Agile Software Development (ASD) and Software Product Lines (SPLs), makes product lines more responsive to ever-changing customer needs or market changes. However, SPLs often fail to keep up with market demand due to high coordination costs, slow development processes, and long release cycles in the case of frequent changes in business requirements; in agile software projects, the lack of a unified specification for describing requirements leads to high coordination costs and inconvenient requirement management. Some studies in the literature have proposed optimized approaches to integrate ASD and SPLs, but they still have not covered all aspects of APLE’s characteristics, and software resource reuse is rarely considered in these approaches during product line development. In view of this, we propose a collaborative framework of agile product line engineering for software resource reuse, namely ScrumOntoSPL. The ScrumOntoSPL approach efficiently merges ASD and SPL based on the agile method Scrum, SPL architecture, and ontology technology. In ScrumOntoSPL, uniform requirement specification is constructed by utilizing ontology, and the Matching Requirement with Component (MRC) process is designed to match product new requirements and software resources stored in a resource pool. In addition, we evaluated the proposed framework and approach with CMMI. In the end, a case study of a software development tool called IMC-Tool based on ScrumOntoSPL for a universal Instrument Microcontroller Chip (IMC) is discussed. The IMC-Tool case illustrates that the ScrumOntoSPL has the advantages of dynamically managing demand changes, enhancing software resource reuse, reducing coordination costs, and reducing time to market.

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.

Cultivation of Craftsmanship Spirit Among Vocational College Students Through Skills Competitions

With the continuous progress of industrial production line technology, more and more frontline workers are needed. The quality of products not only depends on employees’ theoretical knowledge and professional skills, but also their conscientious and responsible work attitude in pursuit of excellence. The importance of cultivating craftsmanship has been recognized by vocational institutions and cultivating students’ craftsmanship has become one of the goals of vocational education. Skills competition is an important part of the vocational education system, in which it not only acts as a platform for students to showcase their capabilities and compete with others, but also promotes the spirit of hard work and craftsmanship and inspires more workers to hone their skills. We reviewed research of scholars and propose that craftsmanship is an inevitable requirement for high-quality development of vocational education. Finally, the article puts forward five targeted suggestions on how to cultivate students’ craftsmanship in the process of skills competition preparation and participation, which can provide reference for vocational institutions in terms of promoting craftsmanship and enrich the cultivation path of craftsmanship.

Annotative Software Product Line Analysis Using Variability-Aware Datalog

Applying program analyses to Software Product Lines (SPLs) has been a fundamental research problem at the intersection of Product Line Engineering and software analysis. Different attempts have been made to “lift” particular product-level analyses to run on the entire product line. In this paper, we tackle the class of Datalog-based analyses (e.g., pointer and taint analyses), study the theoretical aspects of lifting Datalog inference, and implement a lifted inference algorithm inside the Soufflé Datalog engine. We evaluate our implementation on a set of Java and C-language benchmark annotative software product lines. We show significant savings in processing time and fact database size (billions of times faster on one of the benchmarks) compared to brute-force analysis of each product individually.

Computer-Aided Formalization of Internal Consistent Product Family Models

The product line approach enables the rapid building of software products by reusing core assets. How to manage the commonality and variability of product family is the core problem of product line engineering. The feature modeling approach is one of the main approaches to solve this problem. However, this approach does not define the internal functions of features. Some researchers use formal descriptions to define the function of features, but they do not consider the connection between feature specification and feature model. These product family modeling approaches result in product family models that suffer from inconsistent descriptions, which are difficult to resolve manually. To this end, this paper proposes a computer-aided approach to construct an internally consistent product family model. The method performs an inconsistency check during the formalization of each feature in the given initial feature model, pushing the evolution of the feature model and feature specification. The creation and evolution of feature models are achieved through a template-based feature modeling approach. The method is implemented by means of templates, each of which contains two parts of knowledge: the elements required for a class of feature model, and a way to convert the given elements into a formal description. An inconsistency check is achieved through a rule-based detection approach. Each rule contains two parts: a class of conditions that the feature model and the feature specification satisfy, and the actions to resolve inconsistencies once the conditions are satisfied. We have developed a tool. The tool guides the user to build an internally consistent product family model that contains the feature model and feature specifications. Experiments have shown that our approach can provide effective automation support for the process of formal product family modeling.