A generic solution for weaving business code into executable models Eric Cariou Olivier Le Goaer Léa Brunschwig Franck Barbier Univ Pau & Pays Adour Laboratoire d’Informatique de l’Université de Pau et des Pays de l’Adour, EA3000 PAU, France firstname.lastname@univ-pau.fr ABSTRACT However, a problem arises when using and creating an exe- The separation of concerns is a fundamental principle that allows cutable DSL (xDSL) for using such executable models: the data flow to build a software with separate parts, thereby improving their management. Writing a piece of code in a classic way consists in maintainability and evolutivity. Executable models are good poten- weaving a control flow with a data flow. Let’s consider these basic tial representatives of this principle since they capture the behavior lines of Android-inspired Java code: of a software-intensive system, that is, when, why and how calling 1 ... business operations, while the latter are specified apart. EMF is the C u r s o r sms = smsManager . g e t A l l S M S ( ) ; 3 S t r i n g j s o n = c l o u d M a n a g e r . c u r s o r 2 J S O N ( sms ) ; de facto framework used to create an executable DSL (xDSL) but a cloudManager . save ( j s o n ) ; solution to weave business operations into it is still missing. This 5 ... is compounded by the fact that such business operations can be tied to specific technological platforms that stand outside the EMF The first line of code retrieves all the SMS stored into the smart- world (e.g. Android SDK). To that purpose, in this paper we describe phone. Then, this set of SMS is passed as parameter to a second a solution for managing business operations both at design-time method converting them into a neutral JSON format. Finally, in (creation of executable models with EMF) and at run-time (oper- the last line of code, this JSON contents is saved in a Cloud. The ation calls from the deployed execution engine). This solution is control flow consists here in the definition of the sequence of the generic enough to be integrated into any Java-based environment method calls and on which object they are called (here smsManager and for any xDSL. or cloudManager). The data flow consists in passing parameters to the methods and getting the resulting objects that could be further parameters of other methods. Here for instance, the object named KEYWORDS "sms" is obtained by the first method call and passed as parameter to Executable DSL, Xmodeling, operational semantics, CASE tool, EMF the second method. Of course, depending on the business methods, the number and type of parameters can vary as needed. As an example of xDSL for applying our solution for managing 1 INTRODUCTION business operations, we have defined a simple DSL using EMF: PDL Executable modeling (Xmodeling) is receiving increasing atten- for Process Definition Language. A process is composed of a set tion, and hence creation of Executable Domain Specific Languages of ordered activities. The idea is that business operations can be (xDSL) is centerstage. Executable models can be used for simula- associated with each activity. For our Android example, this will tion purpose with mock data and operations, but they may also be lead to define a PDL model with a sequence of three activities, one deployed onto real devices. In that case, the formalism of the DSL for each line of code. From now on, the control flow is reified in the captures the behavior of a system, while an embedded execution form of a PDL model and the software engineer is only in charge of engine is responsible for the proper call of business-level operations implementing the business operations. This is the execution engine (APIs) provided by the targeted platform. of PDL that will carry out the complete execution of the model: For example, each elevator has its own firmware responsible for once the business operation of an activity is finished, it goes to the opening and closing doors, winding/unwinding the cable to reach a next activity and executes its business operation and so on till the given floor. The actions of the elevator may be triggered according end of the process. to a set of states and transitions preferably modeled through a finite However, an important problem remains: how to define the data state machine formalism. As another example, a travel booking flow? How does one set for an activity which is the operation to be system running on a server inserts customers information into a called, on which Java business object and with which parameters? database or call Web services provided by air transport companies. How does one store the result of an operation to reuse it afterward The behavior of such a system specifies when these business rou- as a parameter of the operation of another activity? This problem tines have to be executed and under what conditions. The calls to is not specific to our PDL language but is a recurrent problem the various Web services may be orchestrated through a BPEL or when defining xDSL where executable elements are associated BPMN formalism. with business-level operations. In this paper, we propose a generic EXE 2018, October 14, 2018, Copenhagen, Denmark E. Cariou et al. solution for managing a data flow during the definition of any xDSL. from a state to another one when following a transition, from an It is composed of a set of meta-classes that can be added in any activity to the next one when the current activity is finished. . . So, Ecore metamodel to define a data flow and a set of EMF Java classes these notions of entering and exiting an element can be generalized that are used to define the execution engine thereof and that will to any xDSL. The three operations are optional. However, if one manage automatically the execution of business operations. This does not want to follow our pattern, the operations link between solution is delivered as an Eclipse/EMF plugin called Xmodeling Activity and Xmod_Operation enables to add operations and to Studio 1 . execute them as desired within the execution engine. We took Android as an example because development of an The link between our generic meta-classes and those of an Ecore Android application requires the Android SDK and the Android metamodel can be made in two ways with our Eclipse plugin. If Studio IDE, and it can certainly not be achieved in Eclipse/EMF. In you have an existing metamodel, you have to annotate some meta- this paper, we describe the integration of the execution engine of a classes: by "Xmod_main" for the root element of the Ecore meta- xDSL defined with Xmodeling Studio and how to use its executable model (that will help in the code generation as explained further) models in any Java-based development using any IDE. We are and by "Xmod_action" for elements that need to specialize Xmod_- convinced that being able to push xDSL and models into mainstream Action. Then, you launch a metamodel-to-metamodel transforma- software development (independently of Eclipse/EMF) can lead to tion that will add our generic meta-classes at the right place in your a wider adoption of MDE. metamodel. If you want to build a brand new xDSL, you create an The rest of this paper is organized as follows. In Section 2 we "Empty Xmodeling project". This will create an EMF project with describe how a language engineer implements a xDSL, its meta- an Ecore metamodel containing our generic meta-classes. In both model and execution engine, using Xmodeling Studio. In Section 3, cases, in the "src-gen/" directory of the EMF project, the EMF code we explain how a software engineer uses the xDSL defined in any of our meta-classes will be placed including the built-in code for Java development. Before concluding, we discuss related work in automatically executing business operations. Section 4. 2.2 Execution engine 2 DEFINITION OF A XDSL We provide the implementation of the EMF Java classes with the In this Section, we explain how a language engineer can create a code that will automatically execute business operations. The main xDSL using Xmodeling Studio with associated business operations. part of this implementation is the execute method of Xmod_Ope- As an example, we first define PDL which Ecore meta-model is ration. Based on the tags, it first retrieves in the map the objects depicted on Figure 1. Roughly, a process is composed of a set of that will be the parameters of the method and also the object on activities, has a first and a last activity, and all these activities are which the method has to be called. Based on these objects and the ordered through their next/previous references. The reference method name, a dynamic call of the method is made trough the currentActivity in Process enables to know which is the current reflection mechanism of Java. If the method returns a value, it is active activity when the model is interpreted by the engine. The put in the map with the right tag. meta-classes Xmod_Action and Xmod_Operation (in green) are not An utility class is also automatically generated for managing the part of the PDL definition. They are meta-classes automatically map and the models. It is put for our example in the EMF generated added by Xmodeling Studio for managing business operations as PDL.util package and is called "PDLXmodUtil". This class contains we explain in the following. static Java methods for: 2.1 Meta-classes • Loading a model and getting its root element, based on the The main idea is at run-time to tag the Java objects that will be "Xmod_main" annotation put on one meta-class of the meta- either parameters or return values of business methods and also model. In our example, this annotation has been put on the the objects on which the methods are called. The pairs tag/object Process meta-class, so the generated method will have the are then put in a Java map (java.util.Map) that will be used by following signature: the execution engine to retrieve the objects, as we will see in the Process loadProcess(String fileName) following. • Saving a model through a root element, here again based on A business operation (i.e. a plain Java method in the code) is the "Xmod_main" annotation defined with the meta-class Xmod_Operation. It has a method name, • Getting and setting the object map a set of parameters, a possible return value and the object on which • Loading and saving the in-memory object map through an it will be executed. This information (excepting the method name) XML file corresponds to the tags of the Java objects in the map. During the execution, saving the model and the map allows to The meta-class Activity from PDL metamodel specializes Xmod_- save the complete current state of this application: both its behav- Action. This is how the business operations are added on meta- ioral state and the current contents of the business objects. It can elements. We have leveraged the semantics of UML state machines be used to build an execution trace that can be afterwards analysed for associating business operations as for an UML state: on entry, or to reload and restart the application at a given point in time. on exit and the do action. For almost all xDSL, the execution se- However, depending on the size and number of the Java objects in mantics consists in activating elements and deactivating other ones: the map and on the size of the model, such loading and saving can 1 The tool is available at this address: http://www.pauware.com/xmodeling be heavy-load operations and then should be used sparingly. A generic solution for weaving business code into executable models EXE 2018, October 14, 2018, Copenhagen, Denmark Figure 1: Ecore metamodel of PDL Thanks to this generic code, the implementation of the execu- created with Xtext2 , it will give the model of the Figure 2.b for our tion engine for PDL is straightforward. It consists mainly in imple- Android example. It defines a sequence of three tasks each one as- menting the executeProcess method of Process within the EMF sociated with one business operation (on entry for the two first and generated code: on do for the last one). The "on" enables to express on which object (its tag) the operation will be called, "result" the tag of the returned 1 p u b l i c void e x e c u t e P r o c e s s ( ) { object of the operation. We can notice the tag "allSMSContent" / / get the f i r s t a c t i v i t y of the process 3 Activity act = this . g e t S t a r t ( ) . getReference ( ) ; is the result of the operation of the first activity and is passed as do { parameter for the operation of the second one. In the same way, the 5 / / update the current a c t i v i t y result of the second activity tagged "json" is passed as the parameter this . setCurrentActivity ( act ) ; of the operation of the last activity. This way, the data flow among 7 / / execute the operations of the a c t i v i t y i f activities is automatically managed and our generic implemented / / d e f i n e d by c a l l i n g our i m p l e m e n t e d methods o f 9 / / Xmod_Action t h a t A c t i v i t y i s s p e c i a l i z i n g EMF Java classes will manage the Java objects at run-time through a c t . onEntry ( ) ; their tags. 11 a c t . onDo ( ) ; For the software engineer building a business application, once act . onExit ( ) ; its PDL model defined, he/she has to write a code that will initialize 13 / / go t o t h e n e x t a c t i v i t y act = act . getNext ( ) ; the contents of the map and then launch the process execution. For 15 / / end t h e l o o p i f t h e r e i s no f u r t h e r a c t i v i t y instance, for our small example, it will be something like this: } while ( a c t ! = n u l l ) ; 1 / / c r e a t e t h e i n i t i a l c o n t e n t s o f t h e map w i t h b u s i n e s s 17 } / / o b j e c t s on which methods w i l l be c a l l e d 3 HashMap< S t r i n g , O b j e c t > map = new HashMap < > ( ) ; SMSManager smsManager = new SMSManager ( . . . ) ; 3 IMPLEMENTATION OF A SOFTWARE WITH 5 CloudManager c l o u d M a n a g e r = new CloudManager ( . . . ) ; map . p u t ( " sms " , smsManager ) ; A XDSL 7 map . p u t ( " c l o u d " , c l o u d M a n a g e r ) ; / / l o a d t h e c o n t e n t s o f t h e PDL model t h r o u g h our 3.1 Business code and executable model 9 / / generated u t i l i t a r y c l a s s Once the language engineer has released its xDSL, any software Process proc ; engineer can used it to create a software. He/her has to provide 11 p r o c = PDLXmodUtil . l o a d P r o c e s s ( " SMSBackupWorkflow . xmi " ) ; / / s e t t h e map t h r o u g h our g e n e r a t e d u t i l i t a r y c l a s s an implementation in Java for the business operations (getAllSMS, 13 PDLXmodUtil . setMap ( map ) ; cursor2JSON and save for our Android example). This develop- ment can be made in any Java environment. Then, using EMF, 2 This concrete syntax has not yet been implemented for PDL. Currently, the PDL he/she defines the executable PDL model. If using a textual syntax model is created using the EMF generic XMI file editor as presented on Figure 2.a. EXE 2018, October 14, 2018, Copenhagen, Denmark E. Cariou et al. (a) abstract syntax (b) textual concrete syntax Figure 2: PDL model for the Android application example / / execute the process : the operation of a c t i v i t i e s w i l l the JAR generated from the EMF classes for PDL including the code 15 / / be a u t o m a t i c a l l y c a l l e d by our g e n e r i c meta − c l a s s e s of the PDL execution engine and of our generic code for managing / / and t h e d a t a f l o w i s managed by t h e t a g s i n t h e map the data flow. The SMSBackupW ork f low.xmi file has also to be 17 proc . executeProcess ( ) ; put in the project. 3.2 Deployment 3.3 Discussion Unlike EMF standalone deployment which is done typically export- ing as RCP Application, we need a custom, minimal deployment. At a glance, this way of programming is more complex and less Indeed, the interpreter has no graphical user interface: it is rather convenient than the classic way but this is due to the basic applica- an autonomous executable JAR, able to take XMI files as inputs; tion example and the choice of a minimalist metamodel as a xDSL provided they conform to the metamodel of the given xDSL. The example. Our PDL simply executes one sequence of activities and core libraries coming from EMF that must be isolated from the rest our Java example is a sequence of lines of code. Consequently, in are: both cases, the behavior is reifed under the concept of sequence. Then, the xDSL does not offer a more high-level and abstract way • org.eclipse.emf.common.jar to define the behavioral part of an application. But let’s imagine • org.eclipse.emf.ecore.xmi.jar an extension of PDL with parallel sequences and forks or joins • org.eclipse.emf.ecore.jar among them. In this case, writing by hand in Java an application • org.eclipse.ocl.pivot.jar following this behavior (such as a method that must wait the end of In addition, the package of the ANTLR Parser generated by several parallel methods to be executed) will be a headache whereas Xtext can be embedded so that a concrete textual syntax is also it will be straightforward and much quicker using the extended supported as input. The lightweight, low-dependency and low- PDL formalism as simply requiring to define a model. This high- memory footprint criterion must drive the deployment phase so lights the interest of using xDSL for defining the behavior of an that the interpreter is truly embeddable in tiny devices like Android application. Another benefit of such an approach is that changing smartphones for example (the four above packages have a total the behavior of the application is simply made by modifying the size under 5 MB and even under 2 MB without the OCL run-time model and does not require to change any line of Java code (except verification package). business operations of course). As a proof of concept, we have successfully implemented a simple Using a map requiring to put in it all the objects used as pa- Android application with Android Studio using PDL 3 . It basically rameters, return values and target objects of the business methods requires to add in the project the EMF JAR files listed just above, seems to be fastidious. But if you are using coarse-grained business 3 Sources and technical details are available on http://www.pauware.com/xmodeling/ actions, once the initialization of the business objects on which the android-example.html operations will be called is done and that they have been put in the A generic solution for weaving business code into executable models EXE 2018, October 14, 2018, Copenhagen, Denmark map, the data flow is automatically managed: results of activities engineer can then add the business part of the application in the will mainly be the entries of other ones as defined in the high-level UML models. It enables a 100% model development of a software executable model. It will not be necessary to put many other objects application which is somehow the holy grail of MDD. However in in the map. this case, it is not possible to reuse existing code developed in a standard programming language: everything has to be translated 4 RELATED WORK under the form of UML diagrams and fUML code which is not Several recent research initiatives have been launched to help in an easy task and is indisputably a brake on the use of these full- building executable DSLs and associated tools. The GEMOC Stu- modeling techniques. dio [3] enables to define such DSLs with a lot of tooling features At the complete opposite of these full-modeling approaches but for model edition, simulation, debugging, code generation, defi- still in making a clear separation between the behavioral and the nition of execution engine. . . The GEMOC initiative has for goal business parts, there is a tool such as PauWare5 [2]. PauWare is to integrate different features and works around implementation both a Java library for "programming" UML state machines and an at large of executable DSL. Melange [12] enables also to integrate execution engine for them. Developing with PauWare consists in several DSLs together and to define an execution engine in Ker- instantiating Java library classes for creating the states and tran- meta 34 . [5] and [4] provide generic approaches to add trace and sitions of the state machine and to associate with them business debugging features to any executable DSL. xMOF [15] allows to actions coded through Java methods. With PauWare, everything is defined for MOF-based DSL an execution semantics with fUML [18]. directly defined in plain Java and using it simply required to add a [20] is also using fUML for defining an execution semantics but for JAR file in the Java project of your favorite or required IDE. The UML profiles. Kermeta is an interesting language for developing a UML state machine is not defined with a modeling tool but is reified xDSL: high-level executable code is added by aspect mechanisms under a set of instances of Java classes, that is, at a low level. to meta-classes, making a clear separation between the structural In this paper, we propose an intermediate and pragmatic ap- meta-model and the code manipulating the model. Then, Kermeta proach where the behavioral part of an application is defined with can generate the equivalent Java code, that is, the running execu- an executable model and the business part is defined by the soft- tion engine. All these works offer interesting and powerful features ware engineer in plain Java. This allows him/her to reuse directly which can be inspiring for our Xmodeling CASE tool but they do existing code and to use the IDE he/she prefers or the one that is not explicitly focus on the business part of the software application required such as Android Studio when developing Android mo- to build as we do. bile applications. We propose tools and techniques to glue these Of course business code can be integrated during the software behavioral and business parts together through automatic code development and even legacy code when using these tools. For generation, for any executable DSL. instance, [11] merges existing DSLs using Melange for specifying business and behavorial parts of an IoT (Internet of Thing) applica- 5 CONCLUSION tion. But as the development of the final software is mainly based In this paper, we have presented a solution for weaving business on Eclipse/EMF, it can make difficult to reuse some existing frame- operations into executable elements of any xDSL. Inspired by the works and can even make some developments almost impossible semantics of UML state machines, business operations are associ- as for Android applications. ated with an executable element on entry (when it is actived), on [16] uses a middleware to make interacting a model execution exit (when it is deactivated) and as a do action (when running). We engine (called a virtual machine) for a xDSL with business services. provide generic meta-classes for defining business operations that The description of the business operations is made through ded- can be automatically added to any meta-model. We also provide icated script controls whereas in our approach, there are defined boilerplate EMF Java classes for these meta-classes that contain a directly in the executable model and associated with executable generic code carrying out the automatic execution of the business elements. Their approach deals also with advanced features such operations through the Java reflection mechanism and helping in as runtime adaptability based on context and available resources. the implementation of the execution engine of a xDSL. At run-time, With Xmodeling Studio, we focus only on the execution engine the Java objects (business objects, method parameters or returned implementation and its link with business operations in order to values) are put in a map. Our generic code will access to this map make it the most simple to integrate in any Java-based software to get or set the required objects for an operation execution. This development. enables to manage the data flow among operations while the con- fUML is used in previous citations as a language for defining the trol flow is reified within the executable model. This solution is semantics of a modeling language, i.e. at the metamodeling level, available trough an Eclipse/EMF plugin called Xmodeling Studio. but it has been released originally for defining the equivalent of The originality of this solution is that it is mixing modeling and a programming code in UML models. One can then design for an programming for an easier integration of MDE into everyday soft- application the class diagrams, state machines, sequences diagrams ware developments within the Java ecosystem. Whilst defining a and any required diagrams and then add the contents of the class xDSL for simulation does not required business code, for a concrete methods in fUML either through a kind of activity diagram or software development where using existing API or legacy code is using a pseudo-code syntax thanks to ALF [17]. For instance, [13] unavoidable, the link between these business parts and the exe- generates Java or C++ code from fUML specifications. The software cutable model must be made. The xDSL created with Xmodeling 4 http://www.kermeta.org 5 http://www.pauware.com EXE 2018, October 14, 2018, Copenhagen, Denmark E. Cariou et al. Studio, more precisely their execution engines, can be deployed Foundations and Applications (ECMFA 2013) (LNCS), Vol. 7949. Springer, 37–53. independently of the targeted software or platforms: an Android [9] Peter J. Clarke, Yali Wu, Andrew A. Allen, Frank Hernandez, Mark Allison, and Robert France. 2013. Formal and Practical Aspects of Domain-Specific Languages: application, a Web server, a desktop application, an Arduino pro- Recent Developments. IGI Global, Chapter 9: Towards Dynamic Semantics for gram. . . This is due to the fact the executable model may reify any Synthesizing Interpreted DSMLs. [10] Benoit Combemale, Xavier Crégut, and Marc Pantel. 2012. A Design Pattern kind of application behavior, independently of the business op- to Build Executable DSMLs and associated V&V tools. In The 19th Asia-Pacific erations required. They will be called by our generic EMF Java Software Engineering Conference (APSEC 2012). IEEE. classes. [11] Thomas Degueule, Benoit Combemale, Arnaud Blouin, and Olivier Barais. 2015. Reusing Legacy DSLs with Melange. 15th Workshop on Domain-Specific Model- As perspectives, we will continue the development of Xmodeling ing. Studio with new features. As well-established, an executable model [12] Thomas Degueule, Benoit Combemale, Arnaud Blouin, Olivier Barais, and Jean- contains static and dynamic elements [6–10, 14]. Static elements Marc Jézéquel. 2015. Melange: A Meta-language for Modular and Reusable Development of DSLs. In Proceedings of the 2015 ACM SIGPLAN International define the contents of the model (for PDL, the sequence of activi- Conference on Software Language Engineering (SLE 2015). ACM, New York, NY, ties) whereas dynamic ones are used to manage the execution of USA, 25–36. https://hal.inria.fr/hal-01197038/document [13] Codrut, -Lucian Lazăr, Ioan Lazăr, Bazil Pârv, Simona Motogna, and István-Gergely the model (here the currentActivity reference of Process allow- Czibula. 2010. Tool Support for fUML Models. International Journal of Computers ing to know which is the current activity under execution). The Communications & Control 5, 5 (2010). static elements of the model must not been changed during the [14] Grzegorz Lehmann, Marco Blumendorf, Frank Trollmann, and Sahin Albayrak. 2010. Meta-Modeling Runtime Models. In Models@run.time Workshop at MoDELS execution: if you change the activities of a PDL model, you are 2010 (LNCS), Vol. 6627. Springer. changing the behavior of your software. In some cases, it can be [15] Tanja Mayerhofer, Philip Langer, Manuel Wimmer, and Gerti Kappel. 2013. xMOF: considered for run-time adaptation [8, 19], but in most cases, it Executable DSMLs Based on fUML. In The 2013 International Conference on Soft- ware Language Engineering (SLE ’13) (LNCS), Springer (Ed.), Vol. 8225. Springer, will be an unexpected problem. Hence, we plan to control the code 56–75. written by the language engineer during the implementation of the [16] Karl A. Morris, Mark Allison, Fábio M. Costa, Jinpeng Wei, and Peter J. Clarke. 2015. An adaptive middleware design to support the dynamic interpretation of execution engine of his/her xDSL in order to avoid at run-time the domain-specific models. Information and Software Technology 62 (2015), 21–41. modification of the static elements of the executable models. [17] OMG. 2017. Action Language for Foundational UML (ALF), version 1.1. http://www.omg.org/spec/ALF/1.1/. [18] OMG. 2017. Semantics of a Foundational Subset for Executable UML Models ACKNOWLEDGMENTS (fUML), version 1.3. http://www.omg.org/spec/FUML/1.3/. The presented work is part of the MegaM@RT2 project (Megamod- [19] Samson Pierre, Eric Cariou, Olivier Le Goaer, and Franck Barbier. 2014. A Family- based Framework for i-DSML Adaptation. In 9th European Conference on Mod- eling at Runtime – Scalable Model-based Framework for Contin- elling Foundations and Applications (ECMFA 2014) (LNCS), Vol. 8569. Springer, uous Development and Runtime Validation of Complex Systems) 164–179. [1] which has received funding from the Electronic Component [20] Jérémie Tatibouët, Arnaud Cuccuru, Sébastien Gérard, and François Terrier. 2014. Formalizing Execution Semantics of UML Profiles with fUML Models. In 17th Systems for European Leadership Joint Undertaking (ECSEL-JU) International Conference on Model Driven Engineering Languages and Systems under grant agreement No. 737494. This project receives support (MODELS 2014) (LNCS), Vol. 8767. Springer, 133–148. from the European Union’s Horizon 2020 research and innovation program and from Sweden, Spain, Italy, Finland & Czech Republic. REFERENCES [1] Wasif Afzal, Hugo Bruneliere, Davide Di Ruscio, Andrey Sadovykh, Silvia Mazzini, Eric Cariou, Dragos Truscan, Jordi Cabot, Daniel Field, Luigi Pomante, and Pavel Smrz. 2017. The MegaMRt2 ECSEL Project – MegaModelling at Runtime – Scalable Model-based Framework for Continuous Development and Runtime Validation of Complex Systems. In European Projects in Digital Systems Design (EPDSD), Euromicro DSD/SEAA 2017. [2] Franck Barbier. 2016. Reactive Internet Programming – State Chart XML in Action. the Association for Computing Machinery and Morgan & Claypool. http://www.pauware.com. [3] Erwan Bousse, Thomas Degueule, Didier Vojtisek, Tanja Mayerhofer, Julien Deantoni, and Benoit Combemale. 2016. Execution Framework of the GEMOC Studio (Tool Demo). In Proceedings of the 2016 ACM SIGPLAN International Conference on Software Language Engineering (SLE 2016), ACM (Ed.). https: //hal.inria.fr/hal-01355391 [4] Erwan Bousse, Dorian Leroy, Benoit Combemale, Manuel Wimmer, and Benoit Baudry. 2018. Omniscient Debugging for Executable DSLs. Journal of Sys- tems and Software (2018). http://www.sciencedirect.com/science/article/pii/ S0164121217302765 [5] Erwan Bousse, Tanja Mayerhofer, Benoit Combemale, and Benoit Baudry. 2015. A Generative Approach to Define Rich Domain-Specific Trace Metamodels. In 11th European Conference on Modelling Foundations and Applications (ECMFA 2015) (LNCS), Vol. 9153. Springer, 45–61. [6] Erwan Breton and Jean Bézivin. 2001. Towards an understanding of model executability. In Proceedings of the international conference on Formal Ontology in Information Systems (FOIS ’01). ACM. [7] Eric Cariou, Cyril Ballagny, Alexandre Feugas, and Franck Barbier. 2011. Con- tracts for Model Execution Verification. In Seventh European Conference on Mod- elling Foundations and Applications (ECMFA 2011) (LNCS), Vol. 6698. Springer, 3–18. [8] Eric Cariou, Olivier Le Goaer, Franck Barbier, and Samson Pierre. 2013. Character- ization of Adaptable Interpreted-DSML. In 9th European Conference on Modelling