Modeling Software Product Lines Research Articles

White-box validation of quantitative product lines by statistical model checking and process mining

We propose a novel methodology to validate software product line (PL) models by integrating Statistical Model Checking (SMC) with Process Mining (PM). We consider the feature-oriented language QFLan from the PL engineering domain. QFLan allows to model PL equipped with rich cross-tree and quantitative constraints, as well as aspects of dynamic PLs such as the staged configurations. This richness allows us to easily obtain models with infinite state-space, calling for simulation-based analysis techniques, like SMC. For example, we use a running example with infinite state space. SMC is a family of analysis techniques based on the generation of samples of the dynamics of a system. SMC aims at estimating properties of a system like the probability of a given event (e.g., installing a feature), or the expected value of quantities in it (e.g., the average price of products from the studied family). Instead, PM is a family of data-driven techniques that uses logs collected on the execution of an information system to identify and reason about its underlying execution process. This often regards identifying and reasoning about process patterns, bottlenecks, and possibilities for improvement. In this paper, to the best of our knowledge, we propose, for the first time, the application of Process Mining (PM) techniques to the byproducts of Statistical Model Checking (SMC) simulations. This aims to enhance the utility of SMC analyses. Typically, if SMC gives unexpected results, the modeler has to discover whether these come from actual characteristics of the system, or from bugs in the model. This is done in a black-box manner, only based on the obtained numerical values. We improve on this by using PM to get a white-box perspective on the dynamics of the system observed by SMC. Roughly speaking, we feed the samples generated by SMC to PM tools, obtaining a compact graphical representation of the observed dynamics. This mined PM model is then transformed into a mined QFLan model, making it accessible to PL engineers. Using two well-known PL models, we show that our methodology is effective (helps in pinpointing issues in models, and in suggesting fixes), and that it scales to complex models. We also show that it is general, by applying it to the security domain.

A Model of Reusable Assets in AIE Software Systems

Nowadays, due to the increasing presence of artificial intelligence in software systems, development teams face the challenge of working together to integrate tasks, resources, and roles in a new field, named AI Engineering. Proposals, in the way of models, highlight the needs of integrating two different perspectives – the software and the decision-making support (big data, machine learning, and so on) systems. But there is something more – both systems must achieve high quality levels for different properties; and this is not a straightforward task. Quality properties, such as reusability, traditionally evaluated and reinforced through modeling in software systems, do not exactly apply similarly in decision-making support systems. In this paper, we propose a model for managing reusable assets in AI engineered systems by linking software product line modeling and variety identification. The proposal is exemplified through a case study in the agriculture domain.

Applying declarative analysis to industrial automotive software product line models

Program analysis of automotive software has several unique challenges, including that the code base is ultra large, comprising over a hundred million lines of code running on a single vehicle; the code is structured as a software product line (SPL) for managing a family of related software products from a common set of artifacts; and the analysis results (despite being numerous and despite being variable) need to be presented to the engineer in a way that is manageable. In previous work, we reported on lifting declarative analyses to apply to a software product line, rather than to an individual product variant. This paper reports on milestone results from applying lifted declarative analyses (behaviour alteration, recursion analysis, simplifiable global variable analysis, and two of their variants) to automotive software product lines from General Motors and assessing the scalability of the analyses and the effectiveness of reporting to engineers conditional analysis results (i.e., results conditioned on SPL program variants). We also reflect on some of the lessons learned throughout this project.

Generating Software Product Line Model by Resolving Code Smells in the Products’ Source Code

Software Product Lines (SPLs) refer to some software engineering methods, tools and techniques for creating a collection of similar software systems from a shared set of software assets using a common means of production. This concept is recognized as a successful approach to reuse in software development. Its purpose is to reduce production costs by reusing existing features and managing the variability between the different products with respect of particular constraints. Software Product Line engineering is the production process in product lines and the development of a family of systems by reusing core assets. It exploits the commonalities between software products and preserves the ability to vary the functionalities and features between these products. The adopted strategy for building SPL can be a top-down or bottom-up. Depending from the selected strategy, it is possible to face an inappropriate implementation in the SPL Model or the derived products during this process. The code can contain code smells or code anomalies. Code smells are considered as problems in source code which can have an impact on the quality of the derived products of an SPL. The same problem can be present in many derived products from an SPL due to reuse or in the obtained product line when the bottom-up strategy is selected. A possible solution to this problem can be the refactoring which can improve the internal structure of source code without altering external behavior. This paper proposes an approach for building SPL from source code using the bottom-up strategy. Its purpose is to reduce code smells in the obtained SPL using refactoring source code. This approach proposes a possible solution using reverse engineering to obtain the feature model of the SPL.

Generating Software Product Line Model by Resolving Code Smells in the Products' Source Code

Software Product Lines (SPLs) refer to some software engineering methods, tools and techniques for creating a collection of similar software systems from a shared set of software assets using a common means of production. This concept is recognized as a successful approach to reuse in software development. Its purpose is to reduce production costs by reusing existing features and managing the variability between the different products with respect of particular constraints. Software Product Line engineering is the production process in product lines and the development of a family of systems by reusing core assets. It exploits the commonalities between software products and preserves the ability to vary the functionalities and features between these products. The adopted strategy for building SPL can be a top-down or bottom-up. Depending from the selected strategy, it is possible to face an inappropriate implementation in the SPL Model or the derived products during this process. The code can contain code smells or code anomalies. Code smells are considered as problems in source code which can have an impact on the quality of the derived products of an SPL. The same problem can be present in many derived products from an SPL due to reuse or in the obtained product line when the bottom-up strategy is selected. A possible solution to this problem can be the refactoring which can improve the internal structure of source code without altering external behavior. This paper proposes an approach for building SPL from source code using the bottom-up strategy. Its purpose is to reduce code smells in the obtained SPL using refactoring source code. This approach proposes a possible solution using reverse engineering to obtain the feature model of the SPL.

Classifying and resolving software product line redundancies using an ontological first-order logic rule based method

Software product line engineering improves software quality and diminishes development cost and time by efficiently developing software products. Its success lies in identifying the commonalities and variabilities of a set of software products which are generally modeled using feature models. The success of software product lines heavily relies upon the quality of feature models to derive high quality products. However, there are various defects that reduce profits of software product line. One of such defect is redundancy. While the majority of research work focuses on the identification of redundancies, their causes and corrections have been poorly explored. Causes and corrections must be as accurate and comprehensible as possible in order to support the developer in resolving the cause of a redundancy. This research work classified redundancies in the form of a typology. An ontological first-order logic rule based method is proposed to deal with redundancies. A two-step process is presented for mapping model to ontology based on predicate logic. First-order logic based rules are developed and applied to the generated ontology for identifying redundancies, their causes and corrections to resolve redundancies. The proposed method is illustrated using a case study from software product lines online tools repository. The results of experiments performed on 35 models with varied sizes of real world models as well as automatically-generated models from the Software Product Line Online Tools repository and models created via FeatureIDE tool conclude that the method is accurate, efficient and scalable with FM up to 30,000 features. Thus, enables deriving redundancy free end products from the product line and ultimately, improves its quality.

Model Driven Software Product Line Process for Service/Component-Based Applications

The software reuse becomes the key for companies to improve development costs, time-to-market, and software quality. The Software Product Line Engineering (SPLE) and the Model Driven Engineering (MDE) are two new forms of software reuse. Software product lines are recognized as a successful approach to reuse in many domains (cars, printers, phones…) and especially in software development. Software Product Line Engineering proposes a set of methods, techniques and a common set of software artifacts for the production of customized software products as atomic or composite services to be reused in SOA-based applications. The main purpose of MDE is to enhance productivity by maximizing compatibility between software systems and simplifying the process of design via reuse of standardized models and design patterns. This paper presents a process for the construction of software product lines using model driven techniques. This process is based on a combination of SPLE and the MDE throw the use of visual techniques for modeling product lines and model driven techniques. We have validated the approach with a common example of software product line to evaluate the approach (airline travel agency reservation system). We propose a tool that supports some software product line visual techniques and model driven techniques.

Conditional transition systems with upgrades

• We define two equivalent variants of transition systems having guards. • We define equivalent notions of bisimilarity for both variants and characterise them via a bisimulation game. • We show how to compute bisimilarity symbolically via BDDs. • We provide an extension of the formalism in presence of action precedence. We introduce a variant of transition systems, where activation of transitions depends on conditions of the environment and upgrades during runtime potentially create additional transitions. Using a cornerstone result in lattice theory, we show that such transition systems can be modelled in two ways: as conditional transition systems (CTS) with a partial order on conditions, or as lattice transition systems (LaTS), where transitions are labelled with the elements from a distributive lattice. We define equivalent notions of bisimilarity for both variants and characterise them via a bisimulation game. We explain how conditional transition systems are related to featured transition systems for the modelling of software product lines. Furthermore, we show how to compute bisimilarity symbolically via BDDs by defining an operation on BDDs that approximates an element of a Boolean algebra into a lattice. We have implemented our procedure and provide runtime results. This is an extended version of the TASE 2017 paper [1] , including all proofs, additional examples, an extension of the formalism to account for deactivation of updates and detailed runtime results.

“Sampling” as a Baseline Optimizer for Search-Based Software Engineering

Increasingly, Software Engineering (SE) researchers use search-based optimization techniques to solve SE problems with multiple conflicting objectives. These techniques often apply CPU-intensive evolutionary algorithms to explore generations of mutations to a population of candidate solutions. An alternative approach, proposed in this paper, is to start with a very large population and sample down to just the better solutions. We call this method “Sway”, short for “the sampling way”. This paper compares Sway versus state-of-the-art search-based SE tools using seven models: five software product line models; and two other software process control models (concerned with project management, effort estimation, and selection of requirements) during incremental agile development. For these models, the experiments of this paper show that Sway is competitive with corresponding state-of-the-art evolutionary algorithms while requiring orders of magnitude fewer evaluations. Considering the simplicity and effectiveness of Sway, we, therefore, propose this approach as a baseline method for search-based software engineering models, especially for models that are very slow to execute.

Towards Adaptive Sensor-cloud for Internet of Things

The emerge of the Internet of Things (IoT) data as a commodity to optimize public services such as Fishing Locator has made sensor-cloud an important object. When sensors that are members of multiple IoT gateways can inter-operate at the same time for more than one application, it will reduce cost to deploy IoT infrastructure. However, reliability has also developed as the most important aspect for real-time data collection that should be streamed constantly. Due to uncertainty factors sensors failure is potentially occurred, then an adaptive approach should be addressed into this as to guarantee the flow of streaming data. This paper proposed an adaptive sensor-cloud mechanism to manage the reliability by using a runtime model approach where a transition model and dynamic software product line engineering will take place to weaving the system. Our technique is comparable to other approaches and can be implemented in many types of Cloud-based services.

A Domain-specific Rule Generation Using Model-Driven Architecture in Controlled Variability Model

The business environment changes rapidly and needs to adapt to the enterprise business systems must be considered for new types of requirements to accept changes in the business strategies and processes. This raises new challenges that the traditional development approaches cannot always provide a complete solution in an efficient way. However, most of the current proposals for automatic generation are not devised to cope with rapid integration of the changes in the business requirement of end user (stakeholder’s and customer’s) resource. Domain-specific Rules constitute a key element for domain specific enterprise application, allowing configuration of changes, and management of the domain constraint within a domain. In this paper, we propose an approach to the development of an automatic generation of the domain-specific rules by using variability feature model and ontology definition of domain model concepts coming from Software product line engineering and Model Driven Architecture. We provide a process approach to generate a domain-specific rule based on the end user requirement.

Feature Nets: behavioural modelling of software product lines

Software product lines (SPLs) are diverse systems that are developed using a dual engineering process: (a) family engineering defines the commonality and variability among all members of the SPL, and (b) application engineering derives specific products based on the common foundation combined with a variable selection of features. The number of derivable products in an SPL can thus be exponential in the number of features. This inherent complexity poses two main challenges when it comes to modelling: firstly, the formalism used for modelling SPLs needs to be modular and scalable. Secondly, it should ensure that all products behave correctly by providing the ability to analyse and verify complex models efficiently. In this paper, we propose to integrate an established modelling formalism (Petri nets) with the domain of software product line engineering. To this end, we extend Petri nets to Feature Nets. While Petri nets provide a framework for formally modelling and verifying single software systems, Feature Nets offer the same sort of benefits for software product lines. We show how SPLs can be modelled in an incremental, modular fashion using Feature Nets, provide a Feature Nets variant that supports modelling dynamic SPLs, and propose an analysis method for SPL modelled as Feature Nets. By facilitating the construction of a single model that includes the various behaviours exhibited by the products in an SPL, we make a significant step towards efficient and practical quality assurance methods for software product lines.

Quantitative Analysis of Probabilistic Models of Software Product Lines with Statistical Model Checking

We investigate the suitability of statistical model checking techniques for analysing quantitative properties of software product line models with probabilistic aspects. For this purpose, we enrich the feature-oriented language FLan with action rates, which specify the likelihood of exhibiting particular behaviour or of installing features at a specific moment or in a specific order. The enriched language (called PFLan) allows us to specify models of software product lines with probabilistic configurations and behaviour, e.g. by considering a PFLan semantics based on discrete-time Markov chains. The Maude implementation of PFLan is combined with the distributed statistical model checker MultiVeStA to perform quantitative analyses of a simple product line case study. The presented analyses include the likelihood of certain behaviour of interest (e.g. product malfunctioning) and the expected average cost of products.

Modeling a distributed environment for a petroleum reservoir engineering application with software product line

Petroleum reservoir engineering is a complex and interesting field that requires large amount of computational facilities to achieve successful results. Usually, software environments for this field are developed without taking care out of possible interactions and extensibilities required by reservoir engineers. In this paper, we present a research work which it is characterized by the design and implementation based on a software product line model for a real distributed reservoir engineering environment. Experimental results indicate successfully the utilization of this approach for the design of distributed software architecture. In addition, all components from the proposal provided greater visibility of the organization and processes for the reservoir engineers.

Formal Specification of Software Product Lines: A Graph Transformation Based Approach

A Software Product Line is a set of software products that share a number of core properties but also differ in others. Differences and commonalities between products are typically described in terms of features. A Feature Diagram is a hierarchically structured model that defines the features and their dependencies, while a Featured Transition System is used concisely to model behaviour of each product. In this context, formal modeling and verification are critical for managing the inherent complexity of systems with a high degree of variability. This work presents a formal specification of Software Product Line models based on rewriting logic. We propose an automatic framework for translating featured transition system and feature diagram into an equivalent Maude specification. It is based on meta-modelling and graph transformation. The power of this translation resides in the fact that the proposed formalization preserves source models semantics. An illustrative example is presented. The approach allows various verification and analysis activities. The obtained results are significant.

On the refinement of use case models with variability support

Modeling software product lines shall imply modeling from different perspectives with different modeling artifacts such as use case diagrams, component diagrams, class diagrams, activity diagrams, sequence diagrams and others. In this paper, we elaborate on use cases for modeling product lines and we explore them from the perspective of variability by working with the unified modeling language (UML) «extend» relationship. We also explore them from the perspective of detail by (functionally) refining use cases with «extend» relationships between them. This paper's intent is to provide for comprehension about use case modeling with functional refinement when variability is present.

AoURN-based modeling and analysis of software product lines

Software Product Line Engineering concerns itself with domain engineering and application engineering. During domain engineering, the whole product family is modeled with a preferred flavor of feature models and additional models as required (e.g., domain models or scenario-based models). During application engineering, the focus shifts toward a single family member and the configuration of the member's features. Recently, aspectual concepts have been employed to better encapsulate individual features of a Software Product Line (SPL), but the existing body of SPL work does not include a unified reasoning framework that integrates aspect-oriented feature description artifacts with the capability to reason about stakeholders' goals while taking feature interactions into consideration. Goal-oriented SPL approaches have been proposed, but do not provide analysis capabilities that help modelers meet the needs of the numerous stakeholders involved in an SPL while at the same time considering feature interactions. We present an aspect-oriented SPL approach for the requirements phase that allows modelers (a) to capture features, goals, and scenarios in a unified framework and (b) to reason about stakeholders' needs and perform trade-off analyses while considering undesirable interactions that are not obvious from the feature model. The approach is based on the Aspect-oriented User Requirements Notation (AoURN) and helps identify, prioritize, and choose products based on analysis results provided by AoURN editor and analysis tools. We apply the AoURN-based SPL framework to the Via Verde SPL to demonstrate the feasibility of this approach through the selection of a Via Verde product configuration that satisfies stakeholders' needs and results in a high-level, scenario-based specification that is free from undesirable feature interactions.

AUTOMATED STAGED CONFIGURATION WITH SEMANTIC WEB TECHNOLOGIES

Since the introduction in the early nineties, feature models receive a great deal of attention in industry and academia. Industrial success stories in applying feature models for modeling software product lines, and using them for configuring software-intensive systems motivate academia to discover ways to integrate different feature dependencies into the feature model, and automate verified feature configuration. In this paper we demonstrate how ontologies and Semantic Web technologies facilitate seamless integration of required external services and deployment platform capabilities into the feature model. Furthermore, we also contribute with an algorithm for automating staged configuration using Semantic Web reasoners to discover unfeasible features of the feature model.

An Aspect-Oriented Approach for Use Case Based Modeling of Software Product Lines

Software Product Line Development advocates software reuse by modeling common and variable artefacts separately across members of a family of products. Aspect-Oriented Software Development aims at separation of concerns with “aspects” to increase modularity, reusability, maintainability and ease of evolution. In this paper, we apply an as-pect-oriented use case modeling approach to product line system modeling. A use case specification captures stake-holders concerns as interactions between a system and its actors. We adapt our previous work with the introduction of a “variability” relationship for the expression of variabilities. This relationship is used to model variable and common behaviours across a family of products as use cases. A variability composition mechanism enables building of executa-ble behaviour models for each member of a product line family by integrating common elements with the applicable variable elements.

Multiple-view modelling and meta-modelling of software product lines

A multiple-view modelling and meta-modelling approach for software product lines (SPLs) using the unified modelling language notation is described. A multiple-view model for an SPL defines the different perspectives of the product line, namely the use case model, static model, collaboration model, statechart model and feature model, including the commonality and variability. The meta-model for SPLs depicts the life-cycle phases, views within each phase and meta-classes within each view. The relationships between the different meta-model views are described. Consistency checking rules are specified based on the relationships among meta-classes in the meta-model. These rules, which are specified formally using the object constraint language, are used to resolve inconsistencies between multiple views in the same phase or different phases, and to define allowable mappings between multiple views in different phases. Finally, tool support for the approach is described.