Engineering a ROVER Language in GEMOC S TUDIO & M ONTI C ORE: A Comparison of Language Reuse Support Thomas Degueule Tanja Mayerhofer Andreas Wortmann Centrum Wiskunde & Informatica (CWI) TU Wien RWTH Aachen University Amsterdam, Netherlands Vienna, Austria Aachen, Germany degueule@cwi.nl mayerhofer@big.tuwien.ac.at wortmann@se-rwth.de Abstract—Domain-specific languages (DSLs) improve engineer- operated rovers, with both language workbenches. In these ing productivity through powerful abstractions and automation. implementations, we aimed at reusing as many DSLs as To support the development of DSLs, the software language possible to ease and speed up the DSL engineering process for engineering (SLE) community has produced various solutions the R AS P I ROVER DSL. We show (i) how to develop DSLs for for the systematic engineering of DSLs that manifest in language workbenches. In this paper, we investigate the applicability ofsoftware-controlled rovers with both language workbenches the language workbenches GEMOC S TUDIO and M ONTI C ORE by reusing existing DSLs, (ii) the tool support that both to the MDETools’17 ROVER challenge. To this effect, we refine workbenches offer to engineers for using the developed DSLs, the challenge’s requirements and show how GEMOC S TUDIO and (iii) the individual strengths of GEMOC S TUDIO and and M ONTI C ORE can be leveraged to engineer a Rover-specific DSL by reusing existing DSLs and tooling of GEMOC S TUDIO M ONTI C ORE with regard to their support for engineering DSLs and M ONTI C ORE. Through this, we reflect on the SLE state and supporting tools. We put a particular emphasis on language of the art, detail capabilities of the two workbenches focusingreuse [7] techniques offered by both language workbenches to particularly on language reuse support, and sketch how modelersfacilitate DSL engineering. can approach ROVER programming with modern modeling tools. In the following, Section II details the ROVER challenge Index Terms—Software Language Engineering; Language Reuse; Language Workbenches; Rover; GEMOC Studio; Monti- studied in this paper. Section III and Section IV describe the Core solutions developed with GEMOC S TUDIO and M ONTI C ORE, respectively. Section V compares the language engineering I. I NTRODUCTION support provided by the two studied language workbenches focusing particularly on language reuse. Finally, Section VI Domain-specific languages (DSL) improve software engineer- concludes. ing productivity and system quality through powerful domain abstractions and increased automation. To support DSL develop- II. ROVER L ANGUAGE E NGINEERING C HALLENGE ment, the software language engineering (SLE) [1] community Both GEMOC S TUDIO and M ONTI C ORE have been used has proposed various solutions for the systematic development, in the past for implementing DSLs facilitating the development use, deployment, and maintenance of DSLs and related tools. of software-controlled rovers. The A RDUINO ML language [8] These solutions manifest in language workbenches [2] that has been implemented using GEMOC S TUDIO for modeling assist language engineers in all DSL engineering phases. the architecture and behavior of Arduino-based systems, such In this paper, we present the language workbenches GEMOC as Arduino-operated rovers. The M ONTI A RC AUTOMATON S TUDIO [3] and M ONTI C ORE [4] to demonstrate and compare (MAA) [9] architecture description language has been imple- their language engineering support on the MDETools’17 mented using M ONTI C ORE for modeling the architecture and ROVER challenge [5]. GEMOC S TUDIO is based on the Eclipse behavior of robotics applications, such as the architecture and Modeling Framework (EMF) [6] and provides support for behavior of LEGO NXT operated rovers as well as powerful implementing executable DSLs and supporting tooling. This service robots [9]. While MAA is designed to be a platform- includes meta-programming approaches for defining DSL inter- independent DSL for developing robotics applications running preters and generic components for efficiently developing DSL on any kind of platform, A RDUINO ML is specific to the tools including model animators and debuggers. M ONTI C ORE Arduino platform. offers support for implementing textual DSLs with context-free In this paper, we present a case study on reusing these and grammars and provides a powerful infrastructure for developing other existing DSLs to develop a new R AS P I ROVER DSL analyzers, transformations, and code generators. customized for the development of Raspberry Pi operated We present implementations of the R AS P I ROVER DSL, a rovers, such as the Eclipse PolarSys Rover [10]. Our goal is to DSL for defining the architecture and behavior of Raspberry Pi showcase the language reuse support offered by M ONTI C ORE Rover variable Boolean Boolean 01 program TravelBetweenObstacles() { leftMotor : l l f f frontSensor: 02 var step = 3 cm; number with unit Motor ObstacleSensor 03 while (not message? = "stop") { controller : 04 while (not obstacle-front?) { ControlUnit 05 loop forward step comparison of strings Boolean String rightMotor : inputChannel : 06 } primitive rover action r r m m Motor MessageSubscriber 07 turn 180 deg primitive rover query 08 } 09 } Fig. 1. Example rover hardware architecture defined with R AS P I ROVER DSL Fig. 2. Example rover control program defined with R AS P I ROVER DSL and GEMOC S TUDIO as well as their benefits for facilitating DSL engineering. and conditional statements as well as variables, primitive values, Before we present the implementations of R AS P I ROVER and variable assignments; (2) rover-specific queries and actions, DSL with GEMOC S TUDIO and M ONTI C ORE, we first in particular, dedicated queries for retrieving the temperature describe the requirements imposed on the development of and humidity of a rover’s environment, for obstacles in front R AS P I ROVER DSL regarding desired language features, reuse of and behind the rover, and for messages posted to a central of existing DSLs, and DSL tooling. message board (e.g., messages remotely sent to a rover), as well as actions for moving forward and backward, turning, A. Language Requirements stopping, logging, and sending messages; (3) units for defining To set the language requirements for R AS P I ROVER DSL, distances to travel forward or backward, as well as the rotation we investigated several DSLs that have been used in the angle for turning. past to model rover systems. In particular, we investigated Fig. 1 shows an exemplary rover hardware description model A RDUINO ML and MAA mentioned before, as well as the that should be definable with R AS P I ROVER DSL. It features UML-RT implementation of PAPYRUS -RT [11]. What the a control unit, two motors allowing the rover to drive forward, investigated modeling languages have in common is that they backward, and turn, an obstacle sensor on the front of the provide concepts for modeling both the hardware architecture rover, as well as a message subscriber component allowing the of a rover and the behavior of the rover’s control software. rover to receive input commands. Fig. 2 shows an example There are however considerable differences, in particular in how of a rover control program written with R AS P I ROVER DSL behavioral aspects are described. For instance, A RDUINO ML defining that the rover should travel between two obstacles. In provides an action language for defining the behavior, while particular, it specifies that the rover should travel forward for PAPYRUS -RT relies on UML state machines with embedded 3 cm as long as no obstacle is detected in front of the rover C++ code. Based on our investigations, we decide to include (ll. 4-6). When an obstacle is detected, the rover should turn in R AS P I ROVER DSL a hardware architecture description in the opposite direction (l. 7). This is repeated until a “stop” language and an action language as detailed in the following. command is received via the message board (l. 3). Rover Hardware Architecture Description Language: R AS P I ROVER DSL should enable the definition of the hard- B. Reuse Requirements ware setup of a Raspberry Pi operated rover. This includes Since we focus in this study on a comparison of language defining hardware parts of the rover, such as the different reuse support offered by the investigated language workbenches, actuators and sensors, as well as their connection to the rover’s we require that existing DSLs previously engineered with control unit through describing the mapping of the rover’s GEMOC S TUDIO and M ONTI C ORE should be reused wherever board’s pins to hardware modules. The primary rationale for possible. including the hardware mapping into the DSL is to make this For implementing R AS P I ROVER DSL as specified above, we mapping explicit in a rover model, such that it can be leveraged identify several DSLs that can be reused in GEMOC S TUDIO in code generation and for interacting with the rover when and M ONTI C ORE as shown in Table I. In particular, we aim executing a rover model. to reuse A RDUINO ML for the GEMOC S TUDIO solution, Rover Control Language (RCL): For defining the behavior of as well as MAA and Java/P for the M ONTI C ORE solution. rovers, R AS P I ROVER DSL should provide an imperative rover The GEMOC S TUDIO solution relies on a revised version control language. We choose an action language because even of the unit domain model proposed in [12], while the units if other behavioral languages (such as UML state machines) are implemented by hand in the M ONTI C ORE solution. We are used, an action language is still required to define fine- manually implement the rover-specific queries and actions from grained behaviors. Furthermore, the action language should scratch in both cases. abstract from a concrete programming language used to implement rover control software by providing high-level C. Tool Requirements actions commonly supported by rovers. Therefore, RCL should Regarding tooling support, we want to reuse any existing comprise (1) general control structures, such as blocks, loops, tool of the reused languages for the resulting R AS P I ROVER TABLE I L ANGUAGES REUSED FOR DEVELOPING R AS P I ROVER DSL GEMOC Sub-language M ONTI C ORE S TUDIO Architecture Description A RDUINO ML MAA [9] General Action Language A RDUINO ML Java/P [13] Reused Newly Units from [12] implemented Rover Actions Newly implemented DSL language. This comprises, for instance, editors, model animators, model debuggers and code generators available for A RDUINO ML and MAA. Other than that, we impose no further requirements, as the set of tools that can be developed with GEMOC S TUDIO and M ONTI C ORE is quite diverse. Fig. 3. Using M ELANGE to compose the A RDUINO ML, RCL and U NITS For instance, GEMOC S TUDIO mostly supports graphical languages to form a new customized R AS P I ROVER DSL languages, while M ONTI C ORE focuses on textual languages. As another example, GEMOC S TUDIO specializes in language interpreters while M ONTI C ORE specializes in code generators. the PolarSys rover (i.e., rover actions and units as described in Section II-A), and customize the existing execution semantics III. T HE R AS P I ROVER DSL IN GEMOC S TUDIO (i.e., override certain methods of the interpreter) to make the The GEMOC S TUDIO [3] is a language workbench for different parts fit together. Fig. 3 depicts the definitions of the designing and using executable DSLs. It is built atop various various languages reused for implementing R AS P I ROVER DSL modeling technologies of the Eclipse ecosystem (e.g., EMF, in M ELANGE, along with the definition of the R AS P I ROVER Xtext, Sirius) and contributes new components, such as a model DSL itself. The language implementations are available online.1 animator and a model debugger [14], along with customizable First, the rover control language RCL is defined (ll. 3-6). execution engines [15]. Following the GEMOC approach, the It consists of its abstract syntax, defined in Ecore (l. 4), abstract syntax of a DSL is specified in Ecore [6], its concrete along with its execution semantics defined in K3 (l. 5). syntax in either Xtext or Sirius, and its execution semantics The Units and ArduinoML languages are defined in a using various meta-languages (e.g., K3 [16], ALE [17], or similar way (ll. 7-10 and 11-14). Finally, the RasPiRover xMOF [18]). By specifying these artifacts, users of GEMOC language composes the reused language components in a S TUDIO then enjoy various facilities, e.g., language-specific meaningful way. First, it slices [19] the ArduinoML language debuggers and animators [15]. (l. 17) to extract the hardware-definition part and remove As one of the showcases of the GEMOC S TUDIO, the the Arduino-specific parts that should not be reused in the authors designed A RDUINO ML, a DSL with simulation and new language. Then, it merges the two other languages RCL animation capabilities for designing programs that can be and Units into the RasPiRover DSL (ll. 20-21). Finally, deployed on a given configuration of an Arduino board. The additional K3 aspects are woven to glue together the different metamodel describing the abstract syntax of A RDUINO ML components both syntactically and semantically (l. 22). As consists of two main parts: a description of the hardware an example, Fig. 4 depicts the ProjectToProgramGlue deployed on a given Arduino board (the set of modules and OverridenProjectInterpreter aspects that, respec- and their associated pins), and a description of the scenario tively, insert a new containment reference from ArduinoML’s putting these modules into play with a simple action language Project (l. 1) to RCL’s RoverProgram (l. 3), and override providing basic control structures, variables, and expressions. the execution semantics of Project to instead delegate to The A RDUINO ML language also comes with an associated the interpreter of RCL (ll. 7-9). The renaming clauses (Fig. 3, interpreter. ll. 18-21) simply ensure that all concepts of the three languages Rather than starting the development of a new DSL for the end up in the same logical package. PolarSys rover from scratch, one could reuse some parts of Overall, the M ELANGE meta-language allows us to compose A RDUINO ML and customize them to the specificities of the the three languages and reuse (parts of) their syntax and PolarSys rover, thereby obtaining a customized R AS P I ROVER semantics (interpreter). As a result, the model execution capa- DSL. To achieve this, GEMOC S TUDIO includes M ELANGE, bilities of GEMOC S TUDIO can be employed for executing a meta-language that allows language designers to reuse and R AS P I ROVER DSL models. The main limitation of the reuse compose various DSLs in the creation of new ones [19]. Using support offered by M ELANGE is that the composition operators M ELANGE, it is possible to prune the Arduino-specific parts of the A RDUINO ML language, merge new concepts specific to 1 https://github.com/tdegueul/gemoc-pirover/ rover MontiArc components and connectors, Java/P messaging, scheduling programs Automaton embeds embeds RCL RasPiRover DSL Units Fig. 5. Relationships of the languages reused to implement R AS P I ROVER DSL in M ONTI C ORE Fig. 4. Syntactically and semantically gluing A RDUINO ML’s Project with RCL’s RoverProgram using K3 aspects 01 grammar RCL extends JavaDSL { 02 ForwardAction implements BlockStatement = "forward"; 03 BackwardAction implements BlockStatement = "backward"; 04 LogAction implements BlockStatement = "log" (msg:String); do not cope with concrete syntax, i.e., the concrete syntax of the 05 MessageQuery implements Literal = "receive?"; 06 TemperatureQuery implements Literal = "temperature?"; resulting language must be defined by hand to benefit from the 07 // additional actions and queries animation and debugging facilities of GEMOC S TUDIO. For 08 } more information on the reuse support offered by M ELANGE, 01 grammar RasPiRover extends MontiArcAutomaton, RCL { we refer the interested reader to [19], [20]. 02 start MACompilationUnit; 03 RCLEmbedding implements Element = "behavior" Name "{" Statement+"}"; IV. T HE R AS P I ROVER DSL IN M ONTI C ORE 04 } from MontiArcAutomaton from RCL M ONTI C ORE [4] is a workbench for the development of modular, textual languages based on extended context-free Fig. 6. Grammars RCL and RasPiRover realizing the definition and integration grammars, Java context conditions and translational realizations of R AS P I ROVER DSL into MAA of semantics using template-based code generation. It enables reusing (parts of) languages via inheritance, embedding, and is embedded into RCL. Consequently, the overall language aggregation [21]. Inheritance enables reusing productions composition of R AS P I ROVER DSL is as depicted in Fig. 5. from the inherited grammar for which M ONTI C ORE generates M ONTI C ORE combines the parsers and abstract syntax classes parsers, abstract syntax classes, context condition checking of the languages accordingly. infrastructures, and code generation infrastructures. This sup- ports specializing or extending languages while reusing existing B. Combining Syntaxes for the R AS P I ROVER DSL tooling from the inherited language. With embedding, extension points in the host grammar are filled with productions from Leveraging JAVA /P through inheritance enables the integra- embedded grammars. This enables, for instance, reusing lan- tion of new primitives for rover actions and queries via its guages for well-defined concerns, such as expression languages. various interfaces. To this end, rover actions, which resemble Aggregation loosely combines languages for joint analysis. statements in JAVA /P, are designed to implement JAVA /P’s To this effect, elements used in models of one language Statement interface. This enables the usage of the new actions that reference elements of models of another language (such wherever statements are supported, e.g., loops and conditionals. as references to data types in an architecture language) are Queries, which resemble literals, are analogously designed to interpreted specific to the integration. This integration is implement M ONTI C ORE’s Literal interface, enabling their external to both languages and, hence, does not require use wherever literals are supported. With this, the complete participating languages to be aware of the integration. RCL grammar is only 17 lines of code (15 new productions) as illustrated in Fig. 6 (top). In M ONTI C ORE, embedding is a A. Reusable M ONTI C ORE Languages specific usage of grammar inheritance that links productions Many of the languages required for realizing R AS P I ROVER of the grammar to be embedded into extension points of the DSL are already available in M ONTI C ORE: MAA [9] enables host grammar. For embedding RCL into R AS P I ROVER DSL, describing software components and can thus be reused for the we leverage M ONTI C ORE’s multiple inheritance to realize hardware architecture description language of R AS P I ROVER embedding as linking one interface from the host grammar DSL through language inheritance. For realizing the rover MAA to productions from the embedded grammar RCL. This control language RCL of R AS P I ROVER DSL, JAVA /P, the is depicted in Fig. 6 (bottom). With this, we obtain a textual action language of UML/P [22] can be refined and extended concrete syntax as illustrated in Fig. 7. as required. For this, we can first restrict JAVA /P to feature Well-formedness of RCL programs is checked by new only variable assignments, statements, conditionals, and while- context conditions that ensure, for instance, that results of loops. This is achieved by inheritance, i.e., RCL inherits receive? queries (which return strings) are not compared to from JAVA /P, and an adds additional context condition that numbers. To this end, adapters between the abstract syntax prevents instances of unsupported JAVA /P abstract syntax classes generated from MAA’s ports and RCL’s primitives classes from being used in R AS P I ROVER DSL models. Then enable interpreting the latter as method calls of the appropriate we add new primitives dedicated to movement, sensing, and return types, i.e., whenever M ONTI C ORE looks up what communication to RCL. Furthermore, the U NITS language receive? in the context of JAVA /P is, the adapters return composed component component type name instance name atomic component TABLE II Rover typed incoming port of name p C OMPARISON OF REUSE SUPPORT IN GEMOC S TUDIO AND M ONTI C ORE Obstacles(PINs) RoverController String MessagePublisher Boolean frontSensor f f ctrl p p (PINs) Reuse Support GEMOC S TUDIO M ONTI C ORE pub Boolean Language Components: b int Obstacles(PINs) d d Movement Abstract Syntax backSensor t int b (PINs) h e component RoverController { e mov Concrete Syntax # port in Boolean f, b; elements language s MAA Thermometer Float port in Float t, h; Semantics (PINs) t String port out String p; (interpreters) (generators) thermo port out int d, e; behavior rcl { s while (not message? = "stop") { Transformations language elements embedded RCL HumitdySensor MessageSubscriber while (not obstacle-front?) { Mechanisms: Float (PINs) h sub send temperature? send humitidy? humitidy typed outgoing # G port of name h forward 10 cm Removing Concepts } (slicing) (context condition) component parameter for PIN mapping turn 180 deg textual representation of } } // end of embedded RCL behavior Adding Concepts component RoverController } (merging/inheritance) (inheritance) with embedded RCL G # G # Changing Concepts (weaving/inheritance) (inheritance) Fig. 7. Example R AS P I ROVER DSL model defined in M ONTI C ORE Language Embedding # a method of return type string. With this in place, all JAVA /P well-formedness rules are applied automatically. Java. Hence, M ONTI C ORE focuses on programmatic language engineering. This, however, confronts language engineers with C. Combining Code Generators for the R AS P I ROVER DSL the complexities of Java. Moreover, there is no support for Integrating the behavior of MAA (scheduling, message producing graphical editors for M ONTI C ORE languages. The passing) and RCL (commanding the rover to perform ac- language implementations are available online.2 tions) requires (1) the integration of their template-based V. D ISCUSSION code generators, and (2) a mapping from rover primitives to sending/receiving messages in the architecture (e.g., mapping As illustrated, the language reuse capabilities of GEMOC the primitive forward to sending a messages to a motor). S TUDIO and M ONTI C ORE differ in the language constituents The MAA code generator requires that for embedded that can be reused as shown in Table II. For both workbenches, behavior models (in our case RCL programs), a Java class reusing abstract syntax, semantics, and transformations3 is is generated that implements a specific interface of MAA’s supported. M ONTI C ORE also supports the reuse of concrete common Java run-time environment [9]. This interface pre- syntax as the concrete syntax integrated into the grammars scribes a compute() method that takes a set of named values defining the abstract syntax as well. However, the reuse (read from incoming ports) as input and returns another set mechanisms of GEMOC S TUDIO and M ONTI C ORE differ of named values (that are assigned to outgoing ports) as in their expressiveness (see Table II). While GEMOC S TUDIO output. Every time a component (e.g., a rover’s control unit) supports removing abstract syntax elements through slicing, should execute its behavior, this method is invoked by MAA. M ONTI C ORE only supports removing abstract syntax elements The body of the compute() method is generated by the through well-formedness rules that actively prevent their code generator of RCL. For this, the RCL generator can instantiation. Adding new abstract syntax elements is supported reuse the JAVA /P generator templates for translating control through inheritance by both language workbenches. GEMOC structure, conditionals, etc. The translation of RCL primitives S TUDIO also supports merging two metamodels on joint classes. into sending and receiving messages is specific to the RCL M ONTI C ORE also supports inheriting concrete syntax. Through generator and must be implemented accordingly. To take into inheritance, both workbenches also support to change language account the connection among rover components, the generator concepts, whereas embedding, i.e., specification and binding of takes as additional input a map from RCL primitives to port dedicated language extension points is specific to M ONTI C ORE. names. Based on this, the generator translates actions to sending We also investigated the impact of reuse in GEMOC messages, and queries to receiving messages. S TUDIO and M ONTI C ORE with respect to the reuse that could be achieved in the implementations of R AS P I ROVER DSL. D. Summary For GEMOC S TUDIO, we measured the numbers of reused Overall, M ONTI C ORE facilitates reusing the syntax and metamodel elements (classes, features, operations) and lines semantics of independently developed DSLs. The central of code of the existing interpreters. For the new artifacts, we artifacts for this are M ONTI C ORE grammars, Java context considered the size of the new RCL language (metamodel conditions, the symbol table, and template-based code gen- 2 http://www.se-rwth.de/materials/rcl/ erators, out of which only the grammars require learning 3 Please note that we did not explicitly discuss the reuse of transformations a specific meta-language while the rest is implemented in in this paper. TABLE III C OMPARISON OF REUSE ACHIEVED WITH GEMOC S TUDIO AND M ONTI C ORE (L O C: L INES OF C ODE ; P ROD : P RODUCTIONS ; E LEM : E LEMENTS ) GEMOC S TUDIO M ONTI C ORE Artifact Size of New Artifacts Size of Reused Artifacts Size of New Artifacts Size of Reused Artifacts 141 elem. (RCL metamodel) 21 LoC / 18 Prod. (grammars) Syntax 361 elem. (metamodels) 1,267 LoC / 246 Prod. (grammars) 24 LoC (K3 glue) 4 LoC / 2 Prod. (glue) 281 LoC (RCL interpreter) 439 LoC (generators) Semantics 643 LoC (interpreters) 1,266 LoC (generators) 50 LoC (K3 glue) 1 LoC (Java glue) Reuse-Specific 19 LoC (Melange) - - - and interpreter), the glue code, and the M ELANGE file. For [8] The GEMOC Initiative, “Arduino Modeling GitHub Project.” [Online]. M ONTI C ORE, we measured the lines of code in the new Available: https://github.com/gemoc/arduinomodeling [9] J. O. Ringert, A. Roth, B. Rumpe, and A. Wortmann, “Language and grammars and in the reused grammars, as well as their size Code Generator Composition for Model-Driven Engineering of Robotics in terms of new and reused productions. For M ONTI C ORE’s Component & Connector Systems,” Journal of Software Engineering for generators, we also measured the lines of code of new and Robotics, vol. 6, no. 1, pp. 33–57, 2015. [10] PolarSys, “PolarSys Rover.” [Online]. Available: https://www.polarsys. reused code. The results are depicted in Table III. As can be org/projects/polarsys.rover seen from these results, we could reuse a large portion of [11] The Eclipse Foundation, “Papyrus Real Time.” [Online]. Available: https://eclipse.org/papyrus-rt/ R AS P I ROVER DSL from existing languages and only needed [12] T. Mayerhofer, M. Wimmer, and A. Vallecillo, “Adding Uncertainty and to implement RCL and some glue code from scratch in both Units to Quantity Types in Software Models,” in Proceedings of the 9th language workbenches. International Conference on Software Language Engineering. ACM, 2016, pp. 118–131. VI. C ONCLUSION [13] M. Schindler, Eine Werkzeuginfrastruktur zur agilen Entwicklung mit der UML/P, ser. Aachener Informatik-Berichte, Software Engineering, We presented the quintessential constituents and activities Band 11. Shaker Verlag, 2012. required for implementing R AS P I ROVER DSL, a DSL for [14] E. Bousse, J. Corley, B. Combemale, J. Gray, and B. Baudry, “Support- defining the hardware architecture and control software behav- ing Efficient and Advanced Omniscient Debugging for xDSMLs,” in Proceedings of the 8th International Conference on Software Language ior of rovers, with GEMOC S TUDIO and M ONTI C ORE. For Engineering. ACM, 2015, pp. 137–148. both language workbenches, we could rely on existing DSLs to [15] E. Bousse, T. Degueule, D. Vojtisek, T. Mayerhofer, J. Deantoni, and build the new rover-specific DSL. Through both case studies, B. Combemale, “Execution Framework of the GEMOC Studio (Tool Demo),” in Proceedings of the 9th International Conference on Software we showed how the different language reuse mechanisms are Language Engineering. ACM, 2016, pp. 84–89. applied and highlighted how they differ. We hope that this [16] Inria DiverSE, “K3 – Executable Metamodeling,” 2017. [Online]. supports practitioners in creating custom DSLs with minimal Available: http://diverse-project.github.io/k3/ [17] M. Leduc, T. Degueule, B. Combemale, T. van der Storm, and O. Barais, effort. “Revisiting Visitors for Modular Extension of Executable DSMLs,” in Proceedings of the 20th International Conference on Model-Driven R EFERENCES Engineering Languages and Systems. ACM, 2017. [1] A. Kleppe, Software Language Engineering: Creating Domain-Specific [18] T. Mayerhofer, P. Langer, M. Wimmer, and G. Kappel, “xMOF: Exe- Languages Using Metamodels. Addison-Wesley, 2008. cutable DSMLs based on fUML,” in Proceedings of the 6th International [2] S. Erdweg, T. van der Storm, M. Völter et al., “The State of the Art Conference on Software Language Engineering, ser. Lecture Notes in in Language Workbenches,” in Proceedings of the 6th International Computer Science, vol. 8225. Springer, 2013, pp. 56–75. Conference on Software Language Engineering. Springer International [19] T. Degueule, B. Combemale, A. Blouin, O. Barais, and J.-M. Jézéquel, Publishing, 2013, pp. 197–217. “Melange: A Meta-language for Modular and Reusable Development of [3] The GEMOC Initiative, “The GEMOC Studio,” 2017. [Online]. DSLs,” in Proceedings of the 8th International Conference on Software Available: http://gemoc.org/studio.html Language Engineering. ACM, 2015, pp. 25–36. [4] H. Krahn, B. Rumpe, and S. Völkel, “MontiCore: a framework for [20] T. Degueule, B. Combemale, A. Blouin, O. Barais, and J. Jézéquel, compositional development of domain specific languages,” STTT, vol. 12, “Safe model polymorphism for flexible modeling,” Computer Languages, no. 5, pp. 353–372, 2010. Systems & Structures, vol. 49, pp. 176–195, 2017. [5] Model-Driven Engineering Tools Challenge (MDETools’17), “Rover [21] A. Haber, M. Look, P. M. S. Nazari, A. N. Perez, B. Rumpe et al., Challenge Problem.” [Online]. Available: http://mase.cs.queensu.ca/ “Composition of Heterogeneous Modeling Languages,” in Proceedings mdetools/index.php?id=rover of the 3rd International Conference on Model-Driven Engineering and [6] D. Steinberg, F. Budinsky, M. Paternostro, and E. Merks, EMF: Eclipse Software Development. Springer International Publishing, 2015, pp. Modeling Framework, 2nd ed. Addison-Wesley Professional, 2008. 45–66. [7] S. Erdweg, P. G. Giarrusso, and T. Rendel, “Language Composition Un- [22] B. Rumpe, Modeling with UML: Language, Concepts, Methods. Springer tangled,” in Proceedings of the 12th Workshop on Language Descriptions, International, July 2016. Tools, and Applications. ACM, 2012, pp. 7:1–7:8.