The TTC 2015 Model Execution Case

Abstract. This paper describes a case study for the Transformation Tool Contest (TTC) 2015 concerning the execution of models. The case foresees the specification of the operational semantics of a subset of the UML activity diagram language with transformation languages. In particular, the computation of the end result of the execution of the activity diagrams is targeted as well as the provisioning of a precise trace for the complete execution. The evaluation concerns the correctness of the operational semantics specifications, its understandability and conciseness, as well as its performance

Engineering a ROVER language in GEMOC STUDIO & MONTICORE: A comparison of language reuse support

Domain-specific languages (DSLs) improve engineering productivity through powerful abstractions and automation. To support the development of DSLs, the software language engineering (SLE) community has produced various solutions for the systematic engineering of DSLs that manifest in language workbenches. In this paper, we investigate the applicability of the language workbenches GEMOC STUDIO and MONTICORE to the MDETools’17 ROVER challenge. To this effect, we refine the challenge’s requirements and show how GEMOC STUDIO and MONTICORE can be leveraged to engineer a Rover-specific DSL by reusing existing DSLs and tooling of GEMOC STUDIO and MONTICORE. Through this, we reflect on the SLE state of the art, detail capabilities of the two workbenches focusing particularly on language reuse support, and sketch how modelers can approach ROVER programming with modern modeling tools

Using Physical Quantities in Robot Software Models

One of the challenges of modeling any software application that deals with real-world physical systems resides in the correct representation of numerical values and their units. This paper shows how both measurement uncertainty and units can be effectively incorporated into software models, becoming part of their basic type systems, and illustrates this approach in the particular case of a robot language. We show how our approach allows robot modelers to safely represent and manipulate units and measurement uncertainties of the robots and their elements in a natural manner, statically ensuring unit-safe assignments and operations, as well as the propagation of uncertainty in the computations of derived attributes and operations.Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech

A local and global tour on MOMoT

Many model transformation scenarios require flexible execution strategies as they should produce models with the highest possible quality. At the same time, transformation problems often span a very large search space with respect to possible transformation results. Recently, different proposals for finding good transformation results without enumerating the complete search space have been proposed by using meta-heuristic search algorithms. However, determining the impact of the different kinds of search algorithms, such as local search or global search, on the transformation results is still an open research topic. In this paper, we present an extension to MOMoT, which is a search-based model transformation tool, for supporting not only global searchers for model transformation orchestrations, but also local ones. This leads to a model transformation framework that allows as the first of its kind multi-objective local and global search. By this, the advantages and disadvantages of global and local search for model transformation orchestration can be evaluated. This is done in a case-study-based evaluation, which compares different performance aspects of the local- and global-search algorithms available in MOMoT. Several interesting conclusions have been drawn from the evaluation: (1) local-search algorithms perform reasonable well with respect to both the search exploration and the execution time for small input models, (2) for bigger input models, their execution time can be similar to those of global-search algorithms, but global-search algorithms tend to outperform local-search algorithms in terms of search exploration, (3) evolutionary algorithms show limitations in situations where single changes of the solution can have a significant impact on the solution’s fitness.Ministerio de Economia y Competitividad TIN2015-70560-RJunta de Andalucía P12-TIC-186

XMLText: From XML Schema to Xtext

A multitude of Domain-Specific Languages (DSLs) have been implemented with XML Schemas. While such DSLs are well adopted and flexible, they miss modern DSL editor functionality. Moreover, since XML is primarily designed as a machine-processible format, artifacts defined with XMLbased DSLs lack comprehensibility and, therefore, maintainability. In order to tackle these shortcomings, we propose a bridge between the XML Schema Definition (XSD) language and text-based metamodeling languages. This bridge exploits existing seams between the technical spaces XMLware, modelware, and grammarware as well as closes identified gaps. The resulting approach is able to generate Xtextbased editors from XSDs providing powerful editor functionality, customization options for the textual concrete syntax style, and round-trip transformations enabling the exchange of data between the involved technical spaces. We evaluate our approach by a case study on TOSCA, which is an XML-based standard for defining Cloud deployments. The results show that our approach enables bridging XMLware with modelware and grammarware in several ways going beyond existing approaches and allows the automated generation of editors that are at least equivalent to editors manually built for XML-based languages.European Commission ICT Policy Support Programme 31785

A Generative Approach to Define Rich Domain-Specific Trace Metamodels

International audienceExecutable Domain-Specific Modeling Languages (xDSMLs) open many possibilities for performing early verification and validation (V&V) of systems. Dynamic V&V approaches rely on execution traces, which represent the evolution of models during their execution. In order to construct traces, generic trace metamodels can be used. Yet, regarding trace manipulations, they lack both efficiency because of their sequential structure, and usability because of their gap to the xDSML. Our contribution is a generative approach that defines a rich and domain-specific trace metamodel enabling the construction of execution traces for models conforming to a given xDSML. Efficiency is increased by providing a variety of navigation paths within traces, while usability is improved by narrowing the concepts of the trace metamodel to fit the considered xDSML. We evaluated our approach by generating a trace metamodel for fUML and using it for semantic differencing, which is an important V&V activity in the realm of model evolution. Results show a significant performance improvement and simplification of the semantic differencing rules as compared to the usage of a generic trace metamodel

fREX: fUML-based Reverse Engineering of Executable Behavior for Software Dynamic Analysis

International audienceReverse engineering is still a challenging process, notably because of the growing number, heterogeneity, complexity, and size of software applications. While the analysis of their structural elements has been intensively investigated, there is much less work covering the reverse engineering of their behavioral aspects. To further stimulate research on this topic, we propose fREX as an open framework for reverse engineering of executable behaviors from existing software code bases. fREX currently provides model discovery support for behavior embedded in Java code, employs the OMG's fUML standard language as executable pivot format for dynamic analysis, and uses model transformations to bridge Java and fUML. Thus, fREX also aims at contributing to explore the relationship between programming languages (e.g., Java) and executable mod-eling languages (e.g., fUML). In this paper, we describe the proposed fREX framework and its current reverse engineering support covering some core Java features. In addition we discuss how the framework can be used for performing different kinds of dynamic analysis on existing software, as well as how it could be extended in the future

Breathing new life into models : an interpreter-based approach for executing UML models

Zsfassung in dt. SpracheIm Laufe der letzten Jahre gewann die modellgetriebene Softwareentwicklung, auch bekannt als Model-Driven Development (MDD), enorm an Bedeutung. Dabei wird die Implementierung eines Systems, d.h.der Code, automatisch oder halbautomatisch aus den Modellen generiert.Die Korrektheit dieser Modelle ist demnach von großer Bedeutung. Damit ergibt sich die Notwendigkeit ausführbarer Modelle, die durch ihre Ausführung getestet und validiert werden können. Der objektorientiert Modellierungsstandard UML hat den Nachteil, dass er keine präzise und vollständig spezifizierte Ausführungssemantik besitzt. Die Ausführungssemantik von UML wird nur informell in englischer Prosa definiert und unstrukturiert über den 1000 Seiten umfassenden Standard hinweg verteilt behandelt. Dadurch ergeben sich Mehrdeutigkeiten bezüglich der Interpretation von Modellen, was sich auch in der Inkompatibilität der UML Werkzeuge widerspiegelt.Die OMG erkannte das Bedürfnis nach ausführbaren Modellen sowie die Probleme der Semantikdefinition von UML und entwickelte einen neuen Standard mit dem Titel Semantics of a Foundational Subset of Executable UML Models oder foundational UML (fUML), der im Februar 2011 in Erstversion veröffentlicht wurde. Dieser Standard definiert die präzise und vollständige Semantik einer Untermenge von UML 2, die als foundational UML subset bezeichnet wird.Die Forschungsfrage dieser Arbeit lautet daher: Ist die Semantikdefinition des fUML Standards geeignet, um Programme zu implementieren, die das Ausführen von UML Aktivitätsdiagrammen ermöglichen? Um diese Frage zu beantworten, wurde ein Prototyp für einen Modell-Interpreter entwickelt, der UML Modelle entsprechend der im fUML Standard definierten Ausführungssemantik ausführen und debuggen kann.Dieser Modell-Interpreter konzentriert sich dabei auf die Ausführung von UML Aktivitätsdiagramme, die sich mit der Manipulation von Objekten und Links in einem System beschäftigen. Weiters stellt der Prototyp sinnvolle Debugging-Funktionen zur Verfügung, ähnlich jener Funktionalitäten, die vom Debuggen von Code bekannt sind, wie beispielsweise die schrittweise Ausführung oder das Anzeigen des Debugging-Fortschritts. Die Erfahrungen, die im Zuge der Implementierung dieses Prototyps gewonnen werden konnten zeigen, dass der fUML Standard verwendet werden kann, um Programme zu entwickeln, die das Ausführen von UML Aktivitätsdiagrammen ermöglichen. Gleichzeitig ist aber ein hoher Implementierungsaufwand nötig, um benutzerfreundliche und effizient nutzbare Werkzeuge zu entwickeln, die Funktionalitäten wie das Debuggen von Modellen oder das Ausführen unvollständiger Modelle unterstützen.Over the past years Model-Driven Development (MDD) gained significant popularity. With the usage of this paradigm the software engineering process becomes more model-centric and less code-centric.This means that models become the main artifact in the software development process and therewith the whole software development process relies on these models and their correctness. For this reason the need for executable models that can be tested and validated arose. The de facto standard for modeling software systems is OMG's Unified Modeling Language (UML). The problem is that UML models are not executable because UML has no precise and completely specified semantics. Its semantics is defined informally in English prose and this definition is scattered throughout the standard with about 1000 pages. Because of this situation, ambiguities arise and models can be interpreted and executed in different ways. This also led to the development of execution tools that are not interoperable because they implement different execution semantics.OMG has recognized the need for executable models in an unambiguous way, and has developed a new standard called Semantics of a Foundational Subset of Executable UML Models or foundational UML (fUML) that was released in February 2011. This standard defines the precise execution semantics of a subset of UML 2, the so-called foundational UML subset.The research question of this thesis is as follows. Is the semantics definition of the fUML standard sound and applicable for building tools that enable the execution of UML activity diagrams? To answer this question, a prototype of a model interpreter has been developed in this thesis that is able to execute and debug UML models according to the execution semantics defined in the fUML standard. This model interpreter prototype focuses on executing activity diagrams that model the manipulation of objects and links in a system. Furthermore, the prototype provides reasonable debugging functionality similar to the functionality offered for debugging code like the step-wise execution and the displaying of the debugging progress. The experiences gained during the implementation of the model interpreter prototype led to the following conclusion. The fUML standard is applicable for implementing tools that support the execution of UML activity diagrams, however, high efforts are necessary to develop a user-friendly and efficiently usable tool supporting features like the debugging of models or the execution of incomplete models.9