Search

In Model Driven Engineering (MDE), models are first-class citizens, and model transformation is MDE's "heart and soul". Since model transformations are executed for a family of conforming models, their validity becomes a crucial issue. This paper proposes to explore the question of the formal verification of model transformation properties through a tri-dimensional approach: the transformation involved, the properties of interest addressed, and the formal verification techniques used to establish the properties. This work allows a better understanding of the expected properties for a particular transformation, and facilitates the identification of the suitable tools and techniques for enabling their verification. [ABSTRACT FROM PUBLISHER]

Model executability is now a key concern in model-driven engineering, mainly to support early validation and verification (V&V). Some approaches allow to weave executability into metamodels, defining executable domain-specific modeling languages (DSMLs). Model validation can then be achieved by simulation and graphical animation through direct interpretation of the conforming models. Other approaches address model executability by model compilation, allowing to reuse the virtual machines or V&V tools existing in the target domain. Nevertheless, systematic methods are currently not available to help the language designer in the definition of such an execution semantics and related tools. For instance, simulators are mostly hand-crafted in a tool specific manner for each DSML. In this paper, we propose to reify the elements commonly used to support state-based execution in a DSML. We infer a design pattern (called Executable DSML pattern) providing a general reusable solution for the expression of the executability concerns in DSMLs. It favors flexibility and improves reusability in the definition of semantics-based tools for DSMLs. We illustrate how this pattern can be applied to ease the development of V&V tools. [ABSTRACT FROM PUBLISHER]

Variability on project requirements often implies variability on software processes. To manage such variability, Software Process Lines (SPLs) can be used to represent commonality (i.e., common practices) and variability (i.e., differences) of a set of related software processes. To this end, some Software Process Modeling Languages (SPMLs) natively integrate variability mechanisms. Nevertheless, such a coupling between the SPML and the variability mechanisms i) requires to interpret the requirements variability in terms of the processes variability, ii) limits the reuse of the requirements variability for other purposes (e.g., the development itself), and iii) is a barrier to the use of advances from the field of variability management. In this paper, we propose an approach to apply the Common Variability Language (CVL from the OMG consortium) for requirement variability modeling and its binding to the processes. This work is illustrated on a family of industrial Java development processes. Our approach enables the definition of an SPL and the automatic derivation of a process from this SPL according to the requirements of a given project. The variability is managed separately from the process model and benefits from existing tools coming from the process modeling community and CVL. [ABSTRACT FROM PUBLISHER]

When modeling requirements, software analysts have to choose the relevant modeling constructs among all those available. If they do not choose the right set, their model may lack some important information or their model may contain many superfluous details. In previous work, we proposed to capture the purpose of a model with a set of model operations such as queries or model transformations. Then, modelers can analyze the footprints of these operations, that is, the set of model elements touched during their execution. In this paper, we report on two controlled experiments performed with students to evaluate whether footprinting can help them in creating better models. While our studies did not demonstrate statistically significant benefits of footprinting, they reveal the importance of training and tool support for the analysis of footprints. [ABSTRACT FROM PUBLISHER]

Model driven engineering advocates the separation of concerns during the design time of a system, which leads to the creation of several different models, using several different syntaxes. However, to reason on the overall system, we need to compose these models. Unfortunately, composition of models is done in an ad hoc way, preventing comparison, capitalisation and reuse of the composition operators. In order to improve comprehension and allow comparison of merging and weaving operators, we use category theory to propose a unified framework to formally define merging and weaving of models. We successfully use this framework to compare them, both through the way they are transformed in the formalism, and through several properties, such as completeness or non-redundancy. Finally, we validate this framework by checking that it correctly identifies three tools as performing merging or weaving of models. [ABSTRACT FROM PUBLISHER]