=Paper=
{{Paper
|id=Vol-2019/mdetools_3
|storemode=property
|title=Engineering a ROVER Language in GEMOC STUDIO & MONTICORE: A Comparison of Language Reuse Support
|pdfUrl=https://ceur-ws.org/Vol-2019/mdetools_3.pdf
|volume=Vol-2019
|authors=Thomas Degueule,Tanja Mayerhofer,Andreas Wortmann
|dblpUrl=https://dblp.org/rec/conf/models/DegueuleMW17
}}
==Engineering a ROVER Language in GEMOC STUDIO & MONTICORE: A Comparison of Language Reuse Support==
https://ceur-ws.org/Vol-2019/mdetools_3.pdf
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.