Metamodel-based model conformance and multiview consistency checking

Model-driven development, using languages such as UML and BON, often makes use of multiple diagrams (e.g., class and sequence diagrams) when modeling systems. These diagrams, presenting different views of a system of interest, may be inconsistent. A metamodel provides a unifying framework in which to ensure and check consistency, while at the same time providing the means to distinguish between valid and invalid models, that is, conformance. Two formal specifications of the metamodel for an object-oriented modeling language are presented, and it is shown how to use these specifications for model conformance and multiview consistency checking. Comparisons are made in terms of completeness and the level of automation each provide for checking multiview consistency and model conformance. The lessons learned from applying formal techniques to the problems of metamodeling, model conformance, and multiview consistency checking are summarized

Automated Mapping of UML Activity Diagrams to Formal Specifications for Supporting Containment Checking

Business analysts and domain experts are often sketching the behaviors of a software system using high-level models that are technology- and platform-independent. The developers will refine and enrich these high-level models with technical details. As a consequence, the refined models can deviate from the original models over time, especially when the two kinds of models evolve independently. In this context, we focus on behavior models; that is, we aim to ensure that the refined, low-level behavior models conform to the corresponding high-level behavior models. Based on existing formal verification techniques, we propose containment checking as a means to assess whether the system's behaviors described by the low-level models satisfy what has been specified in the high-level counterparts. One of the major obstacles is how to lessen the burden of creating formal specifications of the behavior models as well as consistency constraints, which is a tedious and error-prone task when done manually. Our approach presented in this paper aims at alleviating the aforementioned challenges by considering the behavior models as verification inputs and devising automated mappings of behavior models onto formal properties and descriptions that can be directly used by model checkers. We discuss various challenges in our approach and show the applicability of our approach in illustrative scenarios.Comment: In Proceedings FESCA 2014, arXiv:1404.043

UML Consistency Rules:a Case Study with Open-Source UML Models

UML models are standard artifacts used by software engineers for designing software. As software is designed, different UML diagram types (e.g., class diagrams and sequence diagrams) are produced by software designers. Since the various UML diagram types describe different aspects of a software system, they are not independent but strongly depend on each other, hence they must be consistent. Inconsistencies cause faults in the final software systems. It is, therefore, paramount that they get detected, analyzed, and fixed. Consistency rules are a useful tool proposed in the literature to detect inconsistencies. They categorize constraints that help in identifying inconsistencies when violated. This case study aims at collecting and analyzing UML models with OCL consistency rules proposed in the literature and at promoting the development of a reference benchmark that can be reused by the (FM-)research community. We collected 33 UML consistency rules and 206 different UML diagrams contained in 34 open-source UML models presented in the literature. We propose an FM-based encoding of the consistency rules in OCL. This encoding allows analyzing whether the consistency rules are satisfied or violated within the 34 UML models. To assess the proposed benchmark, we analyzed how the UML models, consistency rules, diagram types contained in the benchmark help in assessing the consistency of UML models, and the consistency of diagrams across the different software development phases. Our results show that the considered UML models and consistency rules allowed identifying 2731 inconsistencies and that those inconsistencies refer to different software development phases. We concluded that the considered UML models and consistency rules could be considered as an initial benchmark that can be further extended by the research community

Generating Counterexamples of Model-based Software Product Lines: An Exploratory Study

International audienceModel-based Software Product Line (MSPL) engineering ai- ms at deriving customized models corresponding to individ- ual products of a family. MSPL approaches usually promote the joint use of a variability model, a base model expressed in a specific formalism, and a realization layer that maps variation points to model elements. The design space of an MSPL is extremely complex to manage for the engineer, since the number of variants may be exponential and the derived product models have to be conformant to numerous well-formedness and business rules. In this paper, the objec- tive is to provide a way to generate MSPLs, called counterex- amples, that can produce invalid product models despite a valid configuration in the variability model. We provide a systematic and automated process, based on the Common Variability Language (CVL), to randomly search the space of MSPLs for a specific formalism. We validate the effective- ness of this process for three formalisms at different scales (up to 247 metaclasses and 684 rules). We also explore and discuss how counterexamples could guide practitioners when customizing derivation engines, when implementing check- ing rules that prevent early incorrect CVL models, or simply when specifying an MSPL

Pattern-based model transformation: a metamodel-based approach to model evolution

Software systems continue to grow in complexity at a rapid pace, creating systems that are complex to build and evolve. The problems that accompany changes in requirements, system upgrades, and error correction produce a desire for software evolution methods that increase the efficiency and effectiveness of adapting complex software to changes. As software systems evolve, design models must be modified to accommodate the required changes. Techniques that control the changes to models in a systematic manner are a key to model evolution. A process that improves the ability to effectively modify a design, thereby enhancing design qualities, supports the need for improved model evolution techniques. Design patterns are common forms of reusable design experiences. They offer solutions to common design problems, reduce complexity by naming and defining abstractions, and provide a foundation for building reusable software. Well-known pattern solutions are expressed in a natural language as fragments of code which are sometimes difficult to understand and implement by software modelers. With increased focus on development of model-driven approaches, rigorous descriptions of design patterns that capture solutions during design instead of implementation are needed. This research defines an approach for the transformation of models that supports controlled model evolution. More precisely, a process for capturing design patterns in UML class diagrams is defined. This process involves defining a metamodel-level representation which specifies how a software developer can introduce design patterns into existing design models. We defined transformation patterns as an extension of the UML metamodel to characterize source and target model elements. The transformation pattern consists of specialized metamodel elements that specify the structure of source and target metamodels. Transformation patterns were specified for the Abstract Factory, Bridge and Visitor design patterns to show how the model-level transformations can be perform on patterns that represent different functionalities. We developed an action language to specify constructs which add, delete, retrieve and connect model elements. We used the constructs of the action language to define transformation specifications that implement model-level transformations on class diagrams. To determine the potential of this approach we manually implemented the transformation specification on a UML design

Criteria for the verification of feature models

Product Line (PL) based development is a promising approach to develop software intensive systems. Experience already report multiple benefits, such as reduced time to market, better reuse, and reduced development costs. PL modelling languages, in particular to create feature models (FMs), and PL configuration processes are now supported by market tools. Although there is a wealth of research works on the theme of FM verification, there is to our knowledge no comprehensive method, technique or tool. However, it is crucial that when verifying a FM, the right criteria are considered: any error in a FM will inevitably spread to the configured software and generate PL architecture stability issues, with a serious risk of undermining the expected benefits. Dealing with key issues such as selecting the 'right' set of verification criteria or defining a small core of criteria from which all other could be derived calls for a consistent definition of all the criteria. This paper presents an original literature survey of FM verification criteria in which all the criteria are (i) classified according to their purpose and (ii) formalized consistently using first order logic

Towards safer composition

Determining whether a set of features can be composed, or safe composition, is a hard problem in software product line engineering because the number of feature combinations can be exponential. We argue that synergies between current approaches to safe composition should be exploited and propose a combined approach. At the heart of our proposal is a merge operation that creates a behavioural description for the entire product family from a feature diagram and descriptions of individual feature behaviour. As a result, we intend to verify more efficiently safe composition for an exponential number of feature combinations