Amir Molzam Sharifloo

Model-based verification of quantitative non-functional properties for software product lines

Evaluating quality attributes of a design model in the early stages of development can significantly reduce the cost and risks of developing a low quality product. To make this possible, software designers should be able to predict quality attributes by reasoning on a model of the system under development. Although there exists a variety of quality-driven analysis techniques for software systems, only a few work address software product lines. This paper describes how probabilistic model checking techniques and tools can be used to verify non-functional properties of different configurations of a software product line. We propose a model-based approach that enables software engineers to assess their design solutions for software product lines in the early stages of development. Furthermore, we discuss how the analysis time can be surprisingly reduced by applying parametric model checking instead of classic model checking. The results show that the parametric approach is able to substantially alleviate the verification time and effort required to analyze non-functional properties of software product lines.

Verifying Non-functional Properties of Software Product Lines: Towards an Efficient Approach Using Parametric Model Checking

In this paper, we describe how probabilistic model checking techniques and tools can be used to verify non-functional properties of different configurations of a software product line. We propose a model-based approach that enables software engineers to assess their design solutions in the early stages of development. Furthermore, we discuss how verification time can surprisingly be reduced by applying parametric model checking instead of classic model checking, and show that the approach can be effective in practice.

LOVER: Light-Weight fOrmal Verification of adaptivE Systems at Run Time

Adaptive systems are able to modify their behaviors to respond to significant changes at run time such as component failures. In many cases, run-time adaptation is simply replacing a piece of system with a new one without interrupting the system operation. In terms of component-based systems, an adaptation may be defined as replacing a system component with a new version at run time. However, updating a system with new components requires the assurance that the new configuration will fully satisfy the expected requirements. Formal verification has been widely used to guarantee that a system specification satisfies a set of properties. However, applying verification techniques at run time for any potential change can be very expensive and sometimes unfeasible. In this paper, we present a methodology, called LOVER, for the lightweight verification of component-based adaptive systems. LOVER provides a new process model supported with formalisms, verification algorithms and tool to verify a significant subset of CTL properties.

Dealing with Non-Functional Requirements for Adaptive Systems via Dynamic Software Product-Lines

This paper focuses on the development of adaptive software, i.e., software that can automatically adapt its behavior at run-time in response to changes in the surrounding context in which it is situated. Furthermore, we focus on adaptation that is required to ensure continuous satisfaction of non-functional requirements. We propose that the implementation should be architected as a dynamic software product line (DSPL), whose target configurations can be generated dynamically. We discuss how the DSPL can be verified against non-functional requirements at design time through model checking. We also discuss how at run time the appropriate instance of the DSPL can be selected and dynamically installed and enacted as context changes are detected that can be handled correctly by such instance.

Efficient consistency checking of scenario-based product-line specifications

Modern technical systems typically consist of multiple components and must provide many functions that are realized by the complex interaction of these components. Moreover, very 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, it is important that engineers have intuitive, but precise means for specifying the requirements for these systems and have tools for automatically finding inconsistencies within the requirements, because these could lead to costly iterations in the later development. We propose a technique for the scenario-based specification of component interactions based on Modal Sequence Diagrams. Moreover, we developed an efficient technique for automatically finding inconsistencies in the scenario-based specification of many variants at once by exploiting recent advances in the model-checking of product lines. Our evaluation shows benefits of this technique over performing individual consistency checking of each variant specification.

Quantitative Verification of Non-functional Requirements with Uncertainty

We focus on non-functional requirements, such as those concerning reliability, performance, or cost and examine how to support the transition from requirements to design models that can be analyzed formally in quantitative terms. We assume that the initial description is given in behavioral terms, using annotated UML Sequence Diagrams. Annotations are used to express environmental assumptions, which are subject to uncertainty, in probabilistic terms. We also assume that a set of requirements is expressed via Structured English statements, which provide predefined patterns to support specification of common probabilistic properties. We discuss how sequence diagrams can be automatically translated into formal models that support software engineers in reasoning about the application being developed. In particular, requirements are transformed into appropriate logic statements while sequence diagrams are translated into Markov models, which can then be analyzed by using probabilistic model checking.

Modeling and Verification for Probabilistic Properties in Software Product Lines

We propose a model for feature-aware discrete-time Markov chains, called FDTMC, as a basis for verifying probabilistic properties, e.g., Reliability and availability, of product lines. To verify such properties on FDTMC, we compare three techniques. First, we experiment with two different parametric techniques to obtain this formula: the classical one builds it from the model as whole, and a new one that builds it compositionally from a sequence of modules. Finally, we propose a new technique that performs a bounded verification for the whole product line, and thus takes advantage of the high probability of common behaviors of the product line. It computes an approximate formula, represented as an arithmetic decision diagram. Experimental results on a vital signal monitoring system prototype are provided and compared for these techniques aiming at analysing them for scalability issues of size and computational time. They show complementary advantages, and we provide criteria to choose a technique depending on the characteristics of the model.

On requirements verification for model refinements

Conventional formal verification techniques rely on the assumption that a systems specification is completely available so that the analysis can say whether or not a set of properties will be satisfied. On the contrary, modern development lifecycles call for agileincremental and iterativeapproaches to tame the boosting complexity of modern software systems and reduce development risks. We focus here on requirements verification performed in the early exploratory stages on high-level models and we discuss how this can be integrated into an agile approach. We present a new technique to model-check incomplete high-level specifications against formally specified requirements. We do this in the context of incomplete hierarchical Statecharts, verified against a variation of CTL properties. Our approach supports step-wise specification and refinement verification. Verification can be incremental, that is alternative refinements may be separately explored and verification is only replayed for the modified parts. The results are presented by introducing the formalisms, the model-checking algorithm, and the tool we have implemented.

On requirement verification for evolving Statecharts specifications

AbstractSoftware development processes have been evolving from rigid, pre-specified, and sequential to incremental, and iterative. This evolution has been dictated by the need to accommodate evolving user requirements and reduce the delay between design decision and feedback from users. Formal verification techniques, however, have largely ignored this evolution and even when they made enormous improvements and found significant uses in practice, like in the case of model checking, they remained confined into the niches of safety-critical systems. Model checking verifies if a system’s model