scispace - formally typeset
Search or ask a question
Proceedings ArticleDOI

Proof Composition for Deductive Verification of Software Product Lines

TL;DR: This work introduces a classification of existing software product line verification approaches, proposes proof composition as a novel approach and presents a case study to evaluate proof composition and demonstrates that it reduces the effort for verification.
Abstract: Software product line engineering aims at the efficient development of program variants that share a common set of features and that differ in other features. Product lines can be efficiently developed using feature-oriented programming. Given a feature selection and the code artifacts for each feature, program variants can be generated automatically. The quality of the program variants can be rigorously ensured by formal verification. However, verification of all program variants can be expensive and include redundant verification tasks. We introduce a classification of existing software product line verification approaches and propose proof composition as a novel approach. Proof composition generates correctness proofs of each program variant based on partial proofs of each feature. We present a case study to evaluate proof composition and demonstrate that it reduces the effort for verification.

Content maybe subject to copyright    Report

Citations
More filters
BookDOI
01 Jan 2013
TL;DR: Books and internet are the recommended media to help you improving your quality and performance.
Abstract: Inevitably, reading is one of the requirements to be undergone. To improve the performance and quality, someone needs to have something new every day. It will suggest you to have more inspirations, then. However, the needs of inspirations will make you searching for some sources. Even from the other people experience, internet, and many books. Books and internet are the recommended media to help you improving your quality and performance.

565 citations

Journal ArticleDOI
TL;DR: A classification of product-line analyses is proposed to enable systematic research and application in software-product-line engineering and develops a research agenda to guide future research on product- line analyses.
Abstract: Software-product-line engineering has gained considerable momentum in recent years, both in industry and in academia. A software product line is a family of software products that share a common set of features. Software product lines challenge traditional analysis techniques, such as type checking, model checking, and theorem proving, in their quest of ensuring correctness and reliability of software. Simply creating and analyzing all products of a product line is usually not feasible, due to the potentially exponential number of valid feature combinations. Recently, researchers began to develop analysis techniques that take the distinguishing properties of software product lines into account, for example, by checking feature-related code in isolation or by exploiting variability information during analysis. The emerging field of product-line analyses is both broad and diverse, so it is difficult for researchers and practitioners to understand their similarities and differences. We propose a classification of product-line analyses to enable systematic research and application. Based on our insights with classifying and comparing a corpus of 123 research articles, we develop a research agenda to guide future research on product-line analyses.

444 citations

Proceedings ArticleDOI
22 Aug 2011
TL;DR: This work presents a technique based on propositional formulas that enables to reason about program variants rather than feature combinations, and can save effort that is caused by considering the same program variant multiple times, for example, in product-line testing.
Abstract: A software product line is a set of program variants, typically generated from a common code base Feature models describe variability in product lines by documenting features and their valid combinations In product-line engineering, we need to reason about variability and program variants for many different tasks For example, given a feature model, we might want to determine the number of all valid feature combinations or compute specific feature combinations for testing However, we found that contemporary reasoning approaches can only reason about feature combinations, not about program variants, because they do not take abstract features into account Abstract features are features used to structure a feature model that, however, do not have any impact at implementation level Using existing feature-model reasoning mechanisms for program variants leads to incorrect results Hence, although abstract features represent domain decisions that do not affect the generation of a program variant We raise awareness of the problem of abstract features for different kinds of analyses on feature models We argue that, in order to reason about program variants, abstract features should be made explicit in feature models We present a technique based on propositional formulas that enables to reason about program variants rather than feature combinations In practice, our technique can save effort that is caused by considering the same program variant multiple times, for example, in product-line testing

128 citations


Cites background from "Proof Composition for Deductive Ver..."

  • ...Program variants are distinguished in terms of features, which are prominent or distinctive user-visible aspects, qualities, or characteristics of a software system [2]....

    [...]

  • ...• The semantics of feature models describes valid con- figurations and can be used to derive statistics about feature models and to detect inconsistencies in feature models, e.g., dead features which are not contained in any valid configuration or false optional features which are declared as…...

    [...]

Proceedings ArticleDOI
26 Sep 2012
TL;DR: This work presents a family-based approach of deductive verification to prove the correctness of a software product line efficiently and shows that the theorem prover KeY can be used off-the-shelf for this task, without any modifications.
Abstract: A software product line is a set of similar software products that share a common code base. While software product lines can be implemented efficiently using feature-oriented programming, verifying each product individually does not scale, especially if human effort is required (e.g., as in interactive theorem proving). We present a family-based approach of deductive verification to prove the correctness of a software product line efficiently. We illustrate and evaluate our approach for software product lines written in a feature-oriented dialect of Java and specified using the Java Modeling Language. We show that the theorem prover KeY can be used off-the-shelf for this task, without any modifications. Compared to the individual verification of each product, our approach reduces the verification time needed for our case study by more than 85%.

79 citations


Cites methods from "Proof Composition for Deductive Ver..."

  • ...Furthermore, we proposed proof composition for deductive verification of feature-oriented programs [34]....

    [...]

Journal ArticleDOI
TL;DR: An exploratory study on 10 feature-oriented systems found that the majority of feature interactions could be detected based on feature-based specifications, but some specifications have not been modularized properly and require undesirable workarounds to modularization.

74 citations

References
More filters
Proceedings ArticleDOI
16 May 2009
TL;DR: This work unify languages and tools that rely on superimposition by using the language-independent model of feature structure trees (FSTs), and proposes a general approach to the composition of software artifacts written in different languages.
Abstract: Superimposition is a composition technique that has been applied successfully in many areas of software development. Although superimposition is a general-purpose concept, it has been (re)invented and implemented individually for various kinds of software artifacts. We unify languages and tools that rely on superimposition by using the language-independent model of feature structure trees (FSTs). On the basis of the FST model, we propose a general approach to the composition of software artifacts written in different languages, Furthermore, we offer a supporting framework and tool chain, called FEATUREHOUSE. We use attribute grammars to automate the integration of additional languages, in particular, we have integrated Java, C#, C, Haskell, JavaCC, and XML. Several case studies demonstrate the practicality and scalability of our approach and reveal insights into the properties a language must have in order to be ready for superimposition.

231 citations


"Proof Composition for Deductive Ver..." refers methods in this paper

  • ...Our approach is compatible with languages and tools that use superimposition [14]....

    [...]

Journal ArticleDOI
TL;DR: A product-line-aware type system that can type check an entire software product line without generating each variant in isolation and proves formally that all program variants generated from a well typed product line are well typed.
Abstract: Software product line engineering is an efficient means of generating a family of program variants for a domain from a single code base. However, because of the potentially high number of possible program variants, it is difficult to test them all and ensure properties like type safety for the entire product line. We present a product-line-aware type system that can type check an entire software product line without generating each variant in isolation. Specifically, we extend the Featherweight Java calculus with feature annotations for product-line development and prove formally that all program variants generated from a well typed product line are well typed. Furthermore, we present a solution to the problem of typing mutually exclusive features. We discuss how results from our formalization helped implement our own product-line tool CIDE for full Java and report of our experience with detecting type errors in four existing software product line implementations.

181 citations


Additional excerpts

  • ...and annotation-based product lines [26], [27]....

    [...]

Book ChapterDOI
04 Jun 2008
TL;DR: This paper introduces the process algebra PL-CCS as a product line extension of CCS and shows how to model the overall behavior of an entire family within PL- CCP, and introduces multi-valued modal μ-calculus as a property specification language for system families specified in PL-CCC.
Abstract: Software product line engineering combines the individual developments of systems to the development of a family of systems consisting of common and variable assets.In this paper we introduce the process algebra PL-CCS as a product line extension of CCS and show how to model the overall behavior of an entire family within PL-CCS. PL-CCS models incorporate behavioral variability and allow the derivation of individual systems in a systematic way due to a semantics given in terms of multi-valued modal Kripke structures. Furthermore, we introduce multi-valued modal μ-calculus as a property specification language for system families specified in PL-CCS and show how model checking techniques operate on such structures. In our setting the result of model checking is no longer a simple yesor noanswer but the set of systems of the product line that do meet the specified properties.

158 citations


"Proof Composition for Deductive Ver..." refers background in this paper

  • ...In [20], the process calculus CCS is extended with a variant operator to represent a family of processes....

    [...]

Proceedings ArticleDOI
16 Nov 2009
TL;DR: This paper presents an extended model checking approach which takes the product line variability into account when verifying domain artifacts and is able to verify that every permissible product which can be derived from the productline fulfills the specified properties (specified with CTL).
Abstract: In product line engineering individual products are derived from the domain artifacts of the product line. The reuse of the domain artifacts is constraint by the product line variability. Since domain artifacts are reused in several products, product line engineering benefits from the verification of domain artifacts. For verifying development artifacts, model checking is a well-established technique in single system development. However, existing model checking approaches do not incorporate the product line variability and are hence of limited use for verifying domain artifacts. In this paper we present an extended model checking approach which takes the product line variability into account when verifying domain artifacts. Our approach is thus able to verify that every permissible product (specified with I/O-automata) which can be derived from the product line fulfills the specified properties (specified with CTL). Moreover, we use two examples to validate the applicability of our approach and report on the preliminary validation results.

149 citations

Journal ArticleDOI
01 Sep 2010
TL;DR: A type system ensures that every valid program of a well-typed product line is well-TYped, and is developed on the basis of a formal model of a feature-oriented Java-like language.
Abstract: A feature-oriented product line is a family of programs that share a common set of features. A feature implements a stakeholder's requirement and represents a design decision or configuration option. When added to a program, a feature involves the introduction of new structures, such as classes and methods, and the refinement of existing ones, such as extending methods. A feature-oriented decomposition enables a generator to create an executable program by composing feature code solely on the basis of the feature selection of a user--no other information needed. A key challenge of product line engineering is to guarantee that only well-typed programs are generated. As the number of valid feature combinations grows combinatorially with the number of features, it is not feasible to type check all programs individually. The only feasible approach is to have a type system check the entire code base of the feature-oriented product line. We have developed such a type system on the basis of a formal model of a feature-oriented Java-like language. The type system guaranties type safety for feature-oriented product lines. That is, it ensures that every valid program of a well-typed product line is well-typed. Our formal model including type system is sound and complete.

119 citations


"Proof Composition for Deductive Ver..." refers background in this paper

  • ...Product-line–aware type systems were proposed for feature-oriented [24], [25]...

    [...]