Model differencing is concerned with identifying differences among models and constitutes an important prerequisite to efficiently carry out development and change management tasks in model-driven engineering. While most of the existing model differencing approaches focus on identifying differences on the abstract syntax level, we propose to reason about differences on the semantics level. Thereby, we utilize the behavioral semantics specification of the used modeling language, which enables the execution of the compared models, to reason about semantic differences.

Further details about our approach, our implementation based on the semantics specification language xMOF, as well as examples can be found at


We analyzed a set of 121 open UML models regarding the usage frequency of the sublanguages and modeling concepts provided by UML 2.4.1, as well as of UML profiles.

The analyzed models have been created with the UML modeling tool Enterprise Architect, and have been retrieved from the Web.

The following three research questions have been investigated in this study:

  1. What is the usage frequency of UML’s sublanguages?
  2. What is the usage frequency of UML’s modeling concepts?
  3. What is the usage frequency of UML profiles?

Information about the analyzed data set, the analysis process, as well as the results of the analysis are provided at:

The paper titled On the Usage of UML: Initial Results of Analyzing Open UML Models was accepted for publication at the conference Modellierung 2014 which will take place in March at Vienna.


On Thursday, October 3rd 2013, we will give a tool demonstration of xMOF at MoDELS 2013. In this tool demonstration you will learn

  • how you can specify the behavioral semantics of your modeling languages with xMOF and
  • how you can execute your models according to this specification.

In the tool demonstration we will show you our tool support implemented for the Eclipse Modeling Framework based on a simple Petri Net modeling language. You can download an Eclipse bundle with xMOF readily installed as well as the used example at

The following tutorial video provides you a step-by-step guide for specifying the semantics of the Petri Net modeling language and for executing a simple Petri Net model:


When estimating the quality of an application, usually non-functional properties (NFPs) such as utilization or throughput are monitored. Many different analysis and simulation approaches have been proposed to allow an early stage performance analysis on UML model-level. Due to the lack of formal execution semantics of UML, however, many of these approaches transform the UML software model into a dedicated performance model such as queuing networks. This transformation can introduce additional complexity for the user and developers.

We therefore used the previously presented model-based analysis framework on fUML to develop a performance analyzer that can analyze the software model directly. This analyzer executes a number of modeled workload scenarios and performs operational analysis to calculate different performance properties. The workload scenarios represent expected interactions with the software that need to be analyzed.
Classes in the software model can be declared as service centers, which provide different operations that can be requested by a workload scenario. A workload pattern, e.g., Poisson arrival, defines how often a specified scenario is executed. The requests resulting from multiple executions compete for the service centers and need to wait if the service center is busy with another request (resource contention). This temporal overlap hampers the performance of the overall software and is reflected in the different performance properties. Furthermore, our performance analyzer is able to consider multiple instances of the same service center and supports different balancing strategies as well as different dynamic horizontal scaling strategies.

Further details as well as a case study and the related sources can be found at


In MDE, quality of models is an important issue as models constitute the central artifacts in the development process. When executable models are employed, it is possible to validate their functional correctness by applying model testing where the model under test is executed and different properties of the carried out execution are validated. Unfortunately, systematic testing approaches for models are rare.

We developed a testing framework for UML models based on the fUML standard which provides a virtual machine for executing UML activities. This testing framework comprises a test specification language for expressing assertions on the execution behavior of UML activities as well as a test interpreter for evaluating them.

More details on our testing framework for UML can be found at


Recently we investigated the applicability of fUML for specifying the behavioral semantics of domain-specific modeling languages. For this purpose we propose the integration of fUML with MOF into a new metamodeling language xMOF (eXecutable MOF) that allows to specify both the abstract syntax and the behavioral semantics of domain-specific modeling languages.

We developed an implementation of xMOF for the Eclipse Modeling Framework by integrating fUML with Ecore as well as an implementation of an accompanying methodology for defining executable domain-specific modeling languages and for executing domain-specific models based on the language’s semantics specification.

More details on xMOF can be found at


Considering non-functional properties of a software system early in the development process is crucial for guaranteeing that non-functional requirements will be fulfilled by the system under development.

We developed a model-based analysis framework based on fUML for enabling the implementation of model-based analysis tools. This framework enables to carry out model-based analysis of non-functional properties of a software system based on runtime information in the form of traces obtained by executing UML models using the fUML virtual machine. Therefore, the framework integrates UML profile applications with execution traces to enable the consideration of additional information captured in profile applications in the model-based analysis as required for instance in performance analysis.

More details on this topic can be found at

This work is done in collaboration with University of L’Aquila.

SEALAB Quality Group - University of L'Aquila


UML is the most adopted modeling language in industry for specifying the structure and the behavior of systems. Due to its general-purpose nature, UML is used very diversely in industry. To understand how UML is actually used in practice, we developed a script which analyses models created with Enterprise Architect. This script extracts the information which UML element types are used in the model, how they are linked to each other and which UML diagram types are used. By conducting this study we want to find out which parts of UML are actually used in industry and in which combinations they are used. Based on these findings we want to derive improvements of UML itself as well as of UML modeling tools. Also for teaching UML in university courses these results will provide valuable input.

Understanding how UML is actually used in industry is only possible by analyzing real-world models. Therefore we hope for your input to our study. Details on how to participate can be found at


Our paper titled “Towards xMOF: Executable DSMLs based on fUML” will be presented at the 12th Workshop on Domain-Specific Modeling at SPLASH/OOPSLA 2012 on Monday, October 22nd 2012.

This paper proposes to use fUML as a semantics specification language enabling to define the operational semantics of any executable domain-specific modeling language (DSML). The overall goal is to (semi-)automatically derive model execution tools such as debuggers and testing environments for a DSML from its semantics specification based on fUML.

We present our approach for using fUML as semantics specification language by integrating it with MOF into a framework we call xMOF (eXecutable MOF). xMOF merges MOF and fUML resulting in a metamodeling language capable of specifying the abstract syntax of a DSML using MOF constructs, as well as the operational semantics of a DSML by the means of fUML activities. Further, we show on an example how to specify the semantics of a DSML using fUML. To reuse existing runtime infrastructures, we also demonstrate our approach for enabling the usage of external libraries in fUML-based specifications.

Download the paper: ” Towards xMOF: Executable DSMLs based on fUML


On Tuesday, 2nd October 2012, we will present parts of our work at the models@run.time workshop of the 15th International Conference on Model Driven Engineering Languages & Systems (MODELS 2012).
In this talk we present a runtime model for fUML which we elaborated in our recent research. We extended the standardized fUML virtual machine in terms of a dedicated trace model, an event model, and a command API. These extensions enable the analysis of the runtime behavior of an activity, as well as the runtime observation and control of an activity execution.

You can find the paper at

© 2012 moliz by Vienna University of Technology Suffusion theme by Sayontan Sinha