Logic Verification of Product-Line Variant Requirements (original) (raw)
Related papers
4 Logic Verification of Product-Line Variant Requirements
2016
Formal verification of variant requirements has gained much interest in the software product line (SPL) community. Feature diagrams are widely used to model product line variants. However, there is a lack of precisely defined formal notation for representing and verifying such models. This paper presents an approach to modeling and verifying SPL variant feature diagrams using first-order logic. It provides a precise and rigorous formal interpretation of the feature diagrams. Logical expressions can be built by modeling variants and their dependencies by using propositional connectives. These expressions can then be validated by any suitable verification tool. A case study of a Computer Aided Dispatch (CAD) system variant feature model is presented to illustrate the verification process.
Managing and Analysing Software Product Line Requirements
International Journal of Software Engineering & Applications, 2013
Modelling software product line (SPL) features plays a crucial role to a successful development of SPL. Feature diagram is one of the widely used notations to model SPL variants. However, there is a lack of precisely defined formal notations for representing and verifying such models. This paper presents an approach that we adopt to model SPL variants by using UML and subsequently verify them by using firstorder logic. UML provides an overall modelling view of the system. First-order logic provides a precise and rigorous interpretation of the feature diagrams. We model variants and their dependencies by using propositional connectives and build logical expressions. These expressions are then validated by the Alloy verification tool. The analysis and verification process is illustrated by using Computer Aided Dispatch (CAD) system.
Logic-Based Analysis and Verification of Software Product Line Variant Requirement Model
International Journal of Knowledge and Systems Science, 2014
Software Product Line (SPL) provides the facility to systematically reuse of software improving the efficiency of software development regarding time, cost and quality. The main idea of SPL is to identify the common core functionality that can be implemented once and reused afterwards. A variant model has also to be developed to manage the variants of the SPL. Usually, a domain model consisting of the common and variant requirements is developed during domain engineering phase to alleviate the reuse opportunity. The authors present a product line model comprising of a variant part for the management of variant and a decision table to depict the customization of decision regarding each variant. Feature diagrams are widely used to model SPL variants. Both feature diagram and our variant model, which is based on tabular method, lacks logically sound formal representation and hence, not amenable to formal verification. Formal representation and verification of SPL has gained much intere...
Requirements Engineering, 2013
Modern software-intensive systems typically consist of multiple components that provide many functions by their interaction. Moreover, often not only a single product, but a whole product line with different compositions of components and functions must be developed. To cope with this complexity, engineers need intuitive, but precise means for specifying the requirements for these systems and require tools for automatically finding inconsistencies within the requirements, because inconsistencies could lead to costly iterations in the later development. In recent work, we proposed a technique for the scenario-based specification of interactions in product lines by a combination of Modal Sequence Diagrams and Feature Diagrams. Furthermore, we elaborated an efficient consistency-checking technique based on a dedicated model-checking approach for product lines. In this paper, we report on further evaluations that underline significant performance benefits of our approach. We describe further optimizations and detail on how we encode the consistency-checking problem for a model-checker. Many modern software-intensive systems consist of multiple components interacting together to deliver the intended functionality. Often, these systems come in many variants (products) and are managed together as a software product line. This variability is the source of * FNRS research fellow
Goal-oriented modeling and verification of feature-oriented product lines
Software & Systems Modeling, 2014
ABSTRACT Goal models represent requirements and intentions of a software system. They play an important role in the development life cycle of software product lines (SPLs). In the domain engineering phase, goal models guide the development of variability in SPLs by providing the rationale for the variability, while they are used for the configuration of SPLs in the application engineering phase. However, variability in SPLs, which is represented by feature models, usually has design and implementation-induced constraints. When those constraints are not aligned with variability in goal models, the configuration with goal models becomes error prone. To remedy this problem, we propose a description logic (DL)-based approach to represent both models and their relations in a common DL knowledge base. Moreover, we apply reasoning to detect inconsistencies in the variability of goal and feature models. A formal proof is provided to demonstrate the correctness of the reasoning approach. An empirical evaluation shows computational tractability of the inconsistency detection.
Electronic Proceedings in Theoretical Computer Science, 2015
Software Product Line Engineering (SPLE) is a software engineering paradigm that focuses on reuse and variability. Although feature-oriented programming (FOP) can implement software product line efficiently, we still need a method to generate and prove correctness of all product variants more efficiently and automatically. In this context, we propose to manipulate feature modules which contain three kinds of artifacts: specification, code and correctness proof. We depict a methodology and a platform that help the user to automatically produce correct-by-construction product variants from the related feature modules. As a first step of this project, we begin by proposing a language, GFML, allowing the developer to write such feature modules. This language is designed so that the artifacts can be easily reused and composed. GFML files contain the different artifacts mentioned above. The idea is to compile them into FoCaLiZe, a language for specification, implementation and formal proof with some object-oriented flavor. In this paper, we define and illustrate this language. We also introduce a way to compose the feature modules on some examples.
An Approach for Validating Feature Models in Software Product Lines
Journal of Software Engineering, 2013
In a Software Product Line (SPL), a feature model is widely used to represent the commonalities and variabilities of a family of software products. In the process of establishing feature models, the incorrect and inaccurate feature relationships will lead to feature model errors which prevent the effective product configuration. The feature model validation aims to identify the errors existing in a feature model and find the solutions of resolving the errors. The current validation approaches transformed a feature model into a Constraint Satisfaction Problem (CSP) and used off-the-shelf solvers to reason on the CSP. However, the use of solvers might take an infeasible amount of time for validating large scale feature models, as CSP exhibits the exponential complexity and requires a combination of heuristics and combinational search methods. This study developed an efficient validation approach based on the contradictory feature relationships behind the errors. As the contradictory feature relationships were found based on feature relationship propagation, the solvers were not required by this approach. The performance and correctness of this proposed approach were evaluated by comparing with the CSP based approach based on a set of predesigned feature models and a number oflarge-scale feature models.
Formal Specification of Software Product Lines: A Graph Transformation Based Approach
Journal of Software, 2012
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.
Structural Validation of Software Product Line Variants: A Graph Transformations Based Approach
International Journal of Software Engineering & Applications, 2013
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 software product line is usually modeled with a feature diagram, describing the set of features and specifying the constraints and relationships between these features. Each product is defined as a set of features. In this area of research, a key challenge is to ensure correctness and safety of these products. There is an increasing need for automatic tools that can support feature diagram analysis, particularly with a large number of features that modern software systems may have. In this paper, we propose using model transformations an automatic approach to validate products according to dependencies defined in the feature diagram. We first introduce the necessary meta-models. Then, we present the used graph grammars to perform automatically this task using the AToM3 tool. Finally, we show the feasibility of our proposal by means of running examples.