I am currently a member of the MSDL (Modelling, Simulation and Design Lab) under supervision of Prof. Hans Vangheluwe. I am a Post-Doctoral Researcher at the University of Antwerp.

I defended my PhD thesis in February 2016.

I am a post-doctoral researcher at the University of Antwerp.

In 2009 and 2010, my research addressed evolution of modelling languages in the context of model-driven engineering. From the resulting papers below, the paper published in the journal Science of Computer Programming is the most notable. Chapter 3 of my PhD thesis describes this topic. [5] [6] [8] [9] [11] [12]

From 2013, I have been working on verification for domain-specific modelling. This resulted in the ProMoBox approach, a generative approach for the specification and verification of properties at the domain-specific level. We published a number of papers on the topic (see below) and have submitted a paper to IEEE Transactions of Software Engineering, which is under review. Chapter 2 of my PhD thesis describes this topic. [17] [18] [19] [20] [22]

From 2010 onwards, I am investigating the modulair design of domain-specific modelling languages. From 2013, I have been working on semantic adaptation for co-simulation. Chapter 4 of my PhD thesis and a number of papers (see below) describe preliminary work on this topic. Together with Claudio Gomes we continued research and submitted a paper to Simulation: Transactions of the Society for Modeling and Simulation International. [13] [14] [15] [16] [21]

Currently, I focus on:

• Variance in software controllers (Flanders Make ECoVaDeVa ICON project)
• Consistency management and design-space exploration for mechatronic systems (Flanders Make MBSE4Mechatronics SBO project) [28]
• Property modelling [24] [27]
• Test modelling [26]
• Process modelling [28]
• User interface and concrete syntax modelling [25] [29]

Evolution of Modelling Languages

In model-driven engineering, evolution is inevitable over the course of the complete life cycle of complex software-intensive systems and more importantly of entire product families. Not only instance models, but also entire modelling languages themselves are subject to change. This is in particular true for domain-specific languages, for which language constructs are tightly coupled to the domain. When this domain evolves, its language must evolve as well.

Up to this day, modelling languages are evolved manually, resulting in tedious and error-prone migration of artifacts such as instance models. My project proposes a structured appoach that enables the design of (semi-)automatic model evolution, with different evolution scenarios for various kinds of modelling artifacts, such as instance models, meta-models and transformation models.

Read more on evolution of modelling languages here.

Modular Design of Modelling Languages

As a natural consequence of the problems we encountered when trying to automate the evolution of modelling languages, the very definition of modelling languages has to be investigated. We do this in two ways: we break down a language (a) according to the structural information of the modelling language, and (b) according to the content of the modelling language.

In the first phase of the project, we intend to split up a modelling language explicitly according to its structural information. Each structural part of the language will be precisely modelled itself. A language will be split up into two formalisms: a design formalism and a property formalism. A design formalism can be used for modelling a software system. A property formalism can be used for capturing the requirements of the system. Indeed, in order to perform meaningful analysis, simulation, model checking or test generation, we need a precise description of the requirements of the system. Including a property formalism in a modelling language enables modelling requirements in a domain-specific way at the most appropriate level of abstraction, thus gaining from the benefits of domain-specific modelling. The structure of the design formalism and the property formalism is the same; a formalism merely takes on a role in the context of a particular modelling language. A formalism is explicitly modelled itself, with models representing internal structure, visual representation and translational meaning. After investigating the breakdown of a language, a new question arises: how are the structural parts related so that they form the language? There must exist a satisfaction relation between the property formalism and the modelling formalism. After all, when all properties are satisfied, the model of the system fulfils the requirements. More in detail, there is a relation between the internal structure of the modelling formalism and the translational meaning of the property formalism, which can in practice be implemented as model checkers (that can be satisfied or not satisfied) or test cases (that can pass or fail) that can be executed on the modelled system.

In the second phase, we will consider a language as a composition of re-usable language fragments. In our research, we will consider a language fragment to be a modelling language (i.e., formed by structural parts as described above). This design choice will allow any modelling language to be re-used as a language fragment, and vice versa, any language fragment to be composed of other language fragments. Consequently, modelling languages can be classified in a acyclic, directed graph structure where arcs represent an “is composed of”- relation. Because the graph is acyclic, there will be a number of root nodes that represent the base formalisms. When following traditional modelling language classification such as in OMG’s UML, we expect these base formalisms to be languages for expressing structure, behaviour, constraints and interaction. Because of the background of our research group, we will focus on behavioural languages (but without neglecting the other base formalisms). We will investigate how language fragments can be re-used to compose existing domain- specific languages. When re-using a modelling language, it is not always desirable to re-use it as a whole. A research question arises: how can the appropriate model fragment be created from a modelling language? Therefore, we will investigate a structured approach how a modelling language can be reduced and/or modified in order to devise a language fragment. Additionally, the following question has to be answered: how are the selected model fragments combined to form a language? An approach will be investigated to weave the language fragments. In order to maximise re-use, the structural parts of each language fragment will be re- used, and must be woven. According to the principles of modularity, the coupling will be kept as low as possible. It will be investigated what kind of relations and additional information can be introduced when weaving language fragments.

Verification Support for Modelling Languages

Verifying whether a model satisfies a set of requirements is considered to be an important challenge in DSM. It is nevertheless mostly neglected by current DSM approaches. We present a solution in the form of ProMoBox, a framework that integrates the definition and verification of temporal properties in discrete-time behavioural DSMLs, whose semantics can be described as a schedule of graph rewrite rules. Thanks to the expressiveness of graph rewriting, this covers a very large class of problems. With ProMoBox, the domain user models not only the system with a DSML, but also its properties, input model, run-time state and output trace. A DSML is thus comprised of five sublanguages, which share domain-specific syntax. The sublanguages are generated from a single metamodel, that is annotated to denote the role of each language concept. The operational semantics of the DSML is modelled as a transformation and is annotated with information about input and output. The modelled system and its properties are translated to Promela, and properties are verified with Spin, a tool for explicit state model checking. In case a counterexample is found, its execution trace is transformed to the domain- specific level as a trace model, which can be played out. Thus, whilst modelling and verifying properties, the domain user is shielded from underlying notations and techniques. Following MPM principles, we explicitly model the ProMoBox framework’s process in a Formalism Transformation Graph and Process Model. Furthermore, we evaluate ProMoBox to assert that it supports the specification and verification of properties in a highly flexible and automated way, according to MPM principles.

A second thread is testing. Because techniques such as metamodelling and model transformation allow for a efficient creation of DSMLs, and using DSMLs significantly increases productivity, DSM is very suitable for early prototyping. Many systems that are modelled using DSMLs are reactive, meaning that during their execution, they respond to external input. Because of the complexity of input and response behaviour of reactive systems, it is desirable to test models as early as possible. However, while dedicated testing support for specific DSMLs has been provided, no systematic support exists for testing DSML models according to DSM principles. We use ProMoBox to automatically generate a domain-specific testing framework from an annotated DSML definition. In our approach, the DSML definition consists of a metamodel, a concrete syntax definition and operational semantics described as a schedule of graph rewrite rules, thus covering a large class of DSMLs. Currently, DSMLs with deterministic behaviour are supported, but we provide an outlook to other (nondeterministic, real-time or continuous-time) DSMLs. The generative nature of the approach makes testing support for DSMLs less error-prone while catering the need for early testing. Next, we will investigate how testcases can be generated from ProMoBox properties, according to given coverage criteria.