Accepted Tutorials


Applied Integration of Models and Real-Time Systems using the DCP

Organizers: Martin Krammer and Martin Benedikt
Duration: 0.5 Days
Website: tba

Co-simulation techniques have evolved significantly over the last 10 years. System simulation and hardware-in-the-loop testing are frequently used to develop complex products in many industrial sectors. The Functional Mock-Up Interface (FMI) represents a standardized solution for integration of simulation models, tools and solvers. In practice the integration and coupling of heterogeneous systems still require enormous efforts. Until now no standardized interface or protocol specification is available, which allows the interaction of real-time and non-real-time systems of different vendors.

This tutorial presents the evolutionary history of the ACOSAR project and the resulting technical specification of the Distributed Co-simulation Protocol (DCP). The DCP consists of a data model, a finite state machine, and a communication protocol including a set of protocol data units. The DCP was adopted by Modelica Association as a Modelica Association Project (MAP). The standardization of the DCP allows for a modular and interoperable development between system providers and integrators. In the end, this will lead to more efficient product development and testing. This tutorial highlights some application possibilities for industry and science. The standard document, a reference implementation, and accompanying materials are available under permissive open-source licenses. Attendees of this tutorial may start instantly to adopt this novel technology to integrate their models or real-time systems with low effort.


Shadow Models: Incremental Model Transformations as an Enabler for Language Implementations

Organizers: Markus Voelter and Sascha Lisson
Duration: 0.5 Days
Website: tba

Model-to-model transformations are used to create representations of models that are easy(er) to analyse, they weave in additional concerns, desugar big languages to smaller ones and are ubiquitous in multi-stage generation/compilation chains.

Many use cases require realtime execution of transformations: users expects analysis results to appear immediately as soon as possible, and an important success factor for the adoption of DSLs is that users can simulate and test their models immediately. If transformations are to play a role in this scenario, then the transformations have to run in realtime. MPS has always supported multi-stage transformations in the context of its code generation framework; however, these transformations run in „batch mode“ during the Make process, and are not useful in interactive scenarios. MPS does not support transformations for any other use case.

Over the last year we have been developing Shadow Models, an open source, incremental model transformation infrastructure for MPS. It supports efficient incremental execution of transformations triggered by change events of the input model, execution of analyses or interpreters on the result, and lifting of results back up to the input model.

In this tutorial I will show how realtime transformations influence how we think about language design and implementation. In addition, I will demo how shadow models work and how they integrate with MPS.


MBSE Grid: A Simplified Approach for Modeling Complex Systems

Organizers: Aiste Aleksandraviciene and Aurelijus Morkevicius
Duration: 0.5 Days
Website: tba

After an organization makes the decision to adopt model-based systems engineering (MBSE), it must go a long way before this decision proves right. There are many obstacles in this way, like stories about unsuccessful MBSE applications, insufficient information on how to proceed, and employee resistance to the cultural change to name a few. Neither of them is a true issue, if suitable enablers for MBSE adoption are chosen. Nowadays, MBSE is enabled by Systems Modeling Language (SysML). However, SysML is neither a framework nor a method: it provides no information about the modeling process and thus must be combined with some methodology to become truly applicable. This tutorial introduces one of the methods for MBSE, the MBSE Grid. Its framework is organized in a grid layout, where each cell describes one or more artifacts to deliver throughout the modeling process. The approach is based on experience of various MBSE adoption projects, existing studies in the field, and real-life findings in models’ management at different systems engineering domains. The introduction of the approach is followed by hands on exercises, where every attendee takes part in developing a sample system model by applying the MBSE Grid method.


The ADOxx Metamodeling Platform: Concept, Architecture and Practice

Organizers: Dimitris Karagiannis and Wilfrid Utz
Duration: 0.5 Days
Website: tba

The development of domain specific modeling languages has experienced a growing interest in the past years in industry and academia. This evolution can be attributed to the need to design, describe and analyze complex information systems in a coherent and consistent manner using a specific vocabulary and terminology from different background: model artefacts are not observed isolated anymore for a specific purpose, but need to be understood in the context of an organization ecosystem. In such an environment, domain specificity enables the modelers to express focused models using tailored domain concepts that are commonly understood by human stakeholders and at the after semantic transformation enable machine processing to generate model value. To enable such a setting, platform support for conceptual modeling is required that adapts iteratively to changing circumstances and domain needs.

This tutorial introduces the open-source metamodeling platform ADOxx as an experimentation environment for researchers and practitioners to realize individual meta-models and model processing functionalities for domain-specific conceptual modeling methods as modeling tools. Specific emphasis is given to the practical nature of the tutorial: participants are encouraged to realize their individual modeling tools in a hands-on setting and experiment with the capabilities of ADOxx to implement meta-models and model processing functionalities from scratch, specialize existing abstract fragments or compose and integrate available outcomes provided by the community. The prototypes realized as part of the tutorial are available thereafter for further refinement, assessment and evaluation.


Model-Driven Software Engineering in Robotics: Models, Tools, Systems, Solutions, Challenges

Organizers: Christian Schlegel and Herman Bruyninckx
Duration: 0.5 Days

The EU H2020 RobMoSys Project ( aims to coordinate the whole robotics community’s best and consorted effort to realize a step change towards a European ecosystem for open and industry-grade model-driven software development for robotics.
RobMoSys already established a first round of modeling structures and according open source Eclipse-based model-driven tooling for robotics. These form the baseline for the RobMoSys real world application pilots. Both, the modeling foundations as well as the tooling baselines, are extended in a community effort supported by cascade funding. The second open call is underway.
A major goal of this tutorial is to give the model-driven approaches of RobMoSys exposition in the “generic” MDE community. The aim is to foster a closer interaction between the MODELS community and the robotics model-driven software engineering community.

For this, the tutorial provides insights into the current state-of-the-art of model-driven software engineering for robotics and according tools as driven by the robotics domain and consolidated via RobMoSys. It is also about explicating the special needs of robotics and discussing these with the MDE community.

Basically, this should attract more researchers towards challenging robotics problems. It should also allow practitioners to better understand what kind of model-driven tools are already now mature enough to be used for software engineering in robotics.


Developing Reactive Systems using Statecharts

Organizers: Simon Van Mierlo, Hans Vangheluwe and Axel Terfloth
Duration: 1 Day
Website: tba

Statecharts, introduced by Harel in 1987, is used to specify complex, timed, reactive, autonomous discrete-event systems. It is an extension of Timed Finite State Automata, adding depth, orthogonality, broadcast communication and history. Its visual representation is based on higraphs, which combine graphs with Euler diagrams. This representation is most suited to represent Statechart models, and many tools offer visual editing and simulation support for the Statecharts formalism. Examples include STATEMATE, RHAPSODY, YAKINDU Statechart Tools, and STATEFLOW.

This tutorial introduces Statechart modeling, simulation, testing, and deployment. We present a general system development method, encoded in a workflow model, which guides developers that use Statecharts for their system development through the different development steps, ultimately arriving at a deployed system. We start by introducing the Statecharts language: its basic concepts (states and transitions) and more advanced ones (hierarchy, orthogonality, and history). For each concept, we explain the syntax and semantics conceptually, and apply it to a running example that is gradually implemented throughout the tutorial. Simulation and testing activities allow for the user to check the behavior of the system before it is deployed. As a last step, the system is deployed by generating code from the model.

As a running example, the behavior of a simple timed, autonomous, reactive system is modeled: a traffic light. We start by developing a purely virtual model of the traffic light to simulate and test it. It is then deployed onto two platforms by generating code: one is a virtual application based on Java, the other is based on an Arduino, connected to a physical “plant” consisting of led-lights and push buttons. By doing so, we illustrate how the platform functions (for displaying the state of the system and generating interrupts) can be bound to the Statechart’s execution (by communicating using events).

We cover a number of advanced topic in this tutorial as well. The example is further developed by demonstrating how multiple Statechart models can be orchestrated: multiple instances of the traffic light can communicate with each other to implement a safe intersection. Additionally, we explore Statechart variants, since Statecharts is not a single language. In fact, it represents a set of families whose semantics can be configured to suit the need of the application. We explore this family and point out where the “variation points” are, how these affect the execution of a Statechart model, and how they can be implemented in a simulator or executor.

Throughout the tutorial, we use YAKINDU as the integrated development environment for Statecharts. It supports all activities for Statecharts modeling, from visually specifying the system, simulating and testing it, and deploying it by generating code.


Qualitative Research Methods for MDE

Organizers: Harald Störrle
Duration: 0.5 Days
Website: tba

Software Engineering is a social activity. It is no wonder, then, that social sciences research methods are becoming increasingly important in SE research, too, including modelingrelated research. However, owing to the cultural mismatch between social sciences and computing sciences, qualitative methods are often dismissed as “soft” and, consequently, they are still not widely adopted. While we will cover some of the philosophical foundations, too, the emphasis of this course is on the practical side of actual research. Therefore, we will devote as much time as is possible to practical, hands-on excercises. In the practical parts, we will focus on interviews as the mainstay of Qualitative Research Methods today.


AI-driven Streamlined Modeling

Organizers: Sagar Sunkle, Suman Roychoudhury, Deepali Kholkar and Vinay Kulkarni
Duration: 0.5 Days
Website: tba

Abstraction and automation of model-driven techniques can be aptly applied to resolve unique challenges faced by modern enterprises. This tutorial describes an AI-driven streamlined modeling architecture encompassing solution approaches to multitude of modeling scenarios. The presented modeling scenarios are real-world case studies from business domains as varied as money market banks to enterprises involved in predictive analytics for infrastructure services, mortgage processing, financial recommendation, and also a supermarket chain. The modeling scenarios from which this architecture emerged, have been resolved with over a couple of decades of experience in spearheading the use of modeling techniques to problem faced by enterprises world over. The participants will learn to establish parallels between their own modeling efforts and the presented architecture, to be able to find further possibilities of abstraction and automation. During the tutorial, we make concrete the practices learned by applying them to the stated case studies.


Physical Systems for Software Modellers

Organizers: Hans Vangheluwe and Cláudio Gomes
Duration: 1 Day
Website: tba

The complex engineered systems we build today get their value from the networking of multi-physical (mechanical, electrical, hydraulic, biochemical, …) and computational (control, signal processing, planning, …) processes, often interacting with a highly uncertain environment. Software plays a pivotal role, both as a component of such systems, often realizing control laws, deployed on a resource-constrained physical platform, and in the construction of enabling modelling and simulation tools.

This two-part tutorial will introduce software modellers to the two main facets of dealing with physical systems through modelling, simulation and (controller) code synthesis.

In the first part, the different levels at which physical systems may be modelled are introduced. This starts with the technological level. At this level, components are considered that can be physically realized with current materials and production methods. Such components are often available off the shelf. They are characterized by the very specific context (also known as Experimental Frame) in which their models are valid. The next level uses the full knowledge of physics and engineering to describe the behaviour of physical components to study a wide variety of properties. To study the possibly turbulent flow of a viscous liquid through a pipe for example, a Navier-Stokes Partial Differential Equations model will be used. Such models are hard to calibrate and simulate accurately and efficiently. The next level considers the often occurring situation where, for the properties of interest, the spatial distribution of the problem can be abstracted and a lumped-parameter (as opposed to distributed-parameter) model can be used. In a translational mechanical context for example, an object with a complex geometry may still be considered as a point mass characterized by a single parameter „mass“. Such models still obey physical conservation laws such as energy conservation. At this level, formalisms such as Bond Graphs that focus on power flow through a system are used. At the next level, the link with physics is weakened and computational components (functions) are added. This leads to the popular Equation-based Object-Oriented modelling languages such as Modelica® and Simscape®. The semantics of such computationally a-causal languages will be explained with particular focus on the process of causality assignment. This leads to the next level at which input-output computational blocks are used. The main disadvantage of this level is that it focuses on „how“ to compute the evolution of state variables over time as opposed the focus on „what“ the governing equations are in equation-based languages, leaving the „how“ to a model compiler.

The second part of the tutorial starts from the computationally causal level. The formalisms used are known as Causal Block Diagrams (CBDs) or Synchronous Data Flow (SDF), with Simulink® as the most notable example. Three different semantics of CBDs will be explained, bridging the gap between the equations resulting from causality assignment described in the first part of the tutorial and their realization in software. This software can either be a simulator (or a Functional Mockup Unit in case of co-simulation) on a digital computer or a controller deployed on a micro-controller or ECU.

One semantics focuses on algebraic CBDs only. Here, time has been abstracted away, which may lead to „algebraic loops“ which need to be detected and revoled. The second semantics focuses on discrete-time CBDs. Time is abstracted as a discrete counter. The introduction of memory in the form of a delay block allows, in combination with feedback loops in the CBD, for the expression of complex dynamics. The third semantics treats time as continuous. To allow for simulation on a digital computer, discretization is required. As such, continuous-time CBDs are approximated and mapped onto discrete-time CBDs. Such approximation introduces numerical errors which must be dealt with.

Even the discretized level is still an idealization as the numerical values as not Real numbers, but are implemented as floating point approximations. Once CBDs are well understood, the tutorial gives a very basic introduction to automatic control. In engineering practice, the behaviour of virtually every physical systems (also known as „plant“) is regulated by some form of controller. The principles of automatic control will be explained by means of the most simple Proportional, Integral and Derivative (PID) controller. The effect of the different parts of such a controller will be explained. A PID controller will be modelled in the form of a continuous-time CBD. This is then the basis for discritezation to a discrete-time CBD and subsequent synthesis of control software. To demonstrate the concepts, a PID controller will be developed and its optimal parameters will be estimated for the simple cruise control of a vehicle.


A Tutorial on Software Engineering Intelligence: Case Studies on Model-Driven Engineering

Organizers: Marouane Kessentini, Xin Yao and Kalyanmoy Deb
Duration: 0.5 Days
Website: tba

The recent advances in Artificial Intelligence (AI) are dramatically impacting the way we are modelling software systems. A large number of computational intelligence based approaches and tools, combining computational search and machine learning, proved to be successful in automating and semi-automating several activities to support developers. However, the adoption of computational intelligence to address model driven engineering problems is still under-explored. In this tutorial, we will give an overview about computational intelligence, why model-driven engineering is a suitable paradigm for computational intelligence and how computational intelligence could benefit from the recent advances in model-driven engineering. Then, we will focus on some case studies that we published around the adaptation of a variety of computational intelligence techniques for model transformations, models evolution, model changes detection, co-evolution, model/metamodel refactoring, models merging, models quality and metamodels matching. To make the tutorial interactive, the participants will have the opportunity to practice our interactive intelligent MDE tools during the tutorial. Finally, we will conclude the tutorial with different suggestions to enhance the adoption of MDE intelligence research into industry, and the lessons that we learned along this journey and our vision about the future of MDE intelligence. The event will target a wide range of researchers and practitioners from both the model-driven engineering and computational intelligence communities and will reduce the gap between them. The participants will learn about the recent advances in computational intelligence and acquire the required skills to apply them for relevant MDE problems.