Generative technologies for model animation in the TopCased platform

International audienceDomain Specific Modeling Languages (DSML) are more and more used to handle high level concepts, and thus bring complex software development under control. The increasingly recurring definition of new languages raises the problem of the definition of support tools such as editor, simulator, compiler, etc. In this paper we propose generative technologies that have been designed to ease the development of model animation tools inside the TopCased platform. These tools rely on the automatically generated graphical editors of TopCased and provide additional generators for building model animator graphical interface. We also rely on an architecture for executable metamodel (i.e., the TopCased model execution metamodeling pattern) to bind the behavioral semantics of the modeling language. These tools were designed in a pragmatic manner by abstracting the various model animators that had been hand-coded in the TopCased project, and then validated by refactoring these animators

Generative technologies for model animation in the TopCased platform

International audienceDomain Specific Modeling Languages (DSML) are more and more used to handle high level concepts, and thus bring complex software development under control. The increasingly recurring definition of new languages raises the problem of the definition of support tools such as editor, simulator, compiler, etc. In this paper we propose generative technologies that have been designed to ease the development of model animation tools inside the TopCased platform. These tools rely on the automatically generated graphical editors of TopCased and provide additional generators for building model animator graphical interface. We also rely on an architecture for executable metamodel (i.e., the TopCased model execution metamodeling pattern) to bind the behavioral semantics of the modeling language. These tools were designed in a pragmatic manner by abstracting the various model animators that had been hand-coded in the TopCased project, and then validated by refactoring these animators

Introducing Simulation and Model Animation in the MDE Topcased Toolkit

International audienceThe Topcased project aims at developing a modular and generic CASE environment for model driven development of safety critical systems. Model validation is a key feature in this project and model simulation is a major way for validation. The purpose of this paper is to present the current Topcased process for building model simulators and animators. After introducing the functional requirements for model simulation and animation, it is explained how simulation is currently being integrated in the Topcased environment, presenting the main components of a simulator: a model animator, a scenario builder and a simulation engine. The approach is illustrated by the presentation of the first simulation experiment conducted in the project: the UML 2 StateMachines case study

A Design Pattern to Build Executable DSMLs and associated V&V tools

International audienceModel 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

Leveraging formal verification tools for DSML users: a process modeling case study

15 pagesIn the last decade, Model Driven Engineering (MDE) has been used to improve the development of safety critical systems by providing early Validation and Verification (V&V) tools for Domain Specific Modeling Languages (DSML). Verification of behavioral models is mainly addressed by translating domain specific models to formal verification dedicated languages in order to use the sophisticated associated tools such as model-checkers. This approach has been successfully applied in many different contexts, but it has a major draw- back: the user has to interact with the formal tools. In this paper, we present an illustrated approach that allows the designer to formally express the expected behavioral properties using a user oriented language -- a temporal extension of OCL --, that is automatically translated into the formal language; and then to get feedback from the assessment of these properties using its domain language without having to deal with the formal verification language nor with the under- lying translational semantics. This work is based on the metamodeling pattern for executable DSML that extends the DSML metamodel to integrate concerns related to execution and behavior

A Design Pattern for Executable DSML

Model executability is now a key concern in model-driven engineering, mainly to support early validation and verification (V&V). Some approaches have allowed to weave executability into metamodels, defining executable domain-specific modeling languages (DSML). Then, model validation may be achieved by 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 not available to help the language designer in the definition of such an execution semantics and related support 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 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 DSML. It favors flexibility and improves reusability in the definition of semantics-based tools for DSML. We illustrate how this pattern can be applied to V&V and models at runtime, and give insights on the development of generic and generative tools for model animators

Formal Verification Integration Approach for DSML

International audienceThe application of formal methods (especially, model check- ing and static analysis techniques) for the verification of safety critical embedded systems has produced very good results and raised the inter- est of system designers up to the application of these technologies in real size projects. However, these methods usually rely on specific verifica- tion oriented formal languages that most designers do not master. It is thus mandatory to embed the associated tools in automated verification toolchains that allow designers to rely on their usual domain-specific modeling languages (DSMLs) while enjoying the benefits of these power- ful methods. More precisely, we propose a language to formally express system requirements and interpret verification results so that system designers (DSML end-users) avoid the burden of learning some formal verification technologies. Formal verification is achieved through trans- lational semantics. This work is based on a metamodeling pattern for executable DSML that favors the definition of generative tools and thus eases the integration of tools for new DSML

Semantics and Execution of Domain Specific Models

In this paper we present a two-level approach to extend the abstract syntax of models with concrete semantics. First, a light-weight execution interface for iteratable models with a generic user interface allows the tool smith to provide arbitrary execution and visualization engine implementations for his or her Domain Specific Modeling Language (DSML). We discuss how the common execution manager runtime allows co-simulations of different model types and engine implementations to provide a flexible framework in the diverse DSML scenery. Second, as a concrete but nevertheless generic implementation of a simulation engine for behavior models, we present semantic model specifications and a runtime interfacing to the Ptolemy II tool suite. As a project in the area of model simulation, the latter provides a mature sophisticated and formally grounded backbone for model execution. We present our approach as an open source Eclipse integration to be an extension to the Eclipse modeling projects. After introducing basic concepts, the paper explains how simulations are currently being integrated into the framework and presents some illustrative case studies also covering UML approaches

Executing Domain-Specific Models in Eclipse: KLEPTO - KIELER leveraging Ptolemy

We present a two-level approach to extend the abstract syntax of domain-specific models with concrete semantics in order to execute such models. First, a light-weight execution infrastructure for executable models with a generic user interface allows the tool smith to provide arbitrary execution and visualisation engine implementations for a Domain-Specific Language (DSL). Second, as a concrete but nevertheless generic implementation of a simulation engine for behaviour models, we present semantic model specifications and a runtime interfacing to the Ptolemy II tool suite as a formally founded backbone for model execution. We present our approach as an open source extension to Eclipse modelling projects