Tutorials

Tutorials
T 1 The Theory and Practice of Modeling Language Design
Bran Selic
T 2 From Model Editors to Modelling Tools: Operationalizing Modelling Methods with ADOxx
Dimitris Karagiannis, Hans-Georg Fill, Srdjan Zivkovic and Wilfried Utz
T 3 Next-Generation Model-based Variability Management: Languages and Tools
Mathieu Acher, Patrick Heymans, Philippe Collet and Philippe Lahire
T 4 How to implement Domain-Specific Modeling Languages: Hands-on
Steven Kelly
T 5 Empirical Studies in Software Engineering and Software Modeling
Michel Chaudron, Marcela Genero and Lars Pareto
T 6 The "Physics" of Notations: A Scientific Approach to Designing Visual Notations for Model Driven Development (MDD)
Daniel Moody
T 7 Applying Model Driven Engineering Technologies in the Creation of Domain Specific Modeling Languages
Bruce Trask and Angel Roman
T 8 Processing Simulink Models with Graph Rewriting-Based Model Transformation

Péter Fehér, Pieter J. Mosterman, Tamás Mészáros and László Lengyel

T 9 Category Theory and Model-Driven Engineering: Beyond formal semantics
Zinovy Diskin and Tom Maibaum
T 10 Language Workbenches, Embedded Software and Formal Verification
Markus Voelter and Daniel Ratiu
T 11 Concern-Driven Development: Tool-supported Transformation of Requirements Models to Design Models

Gunter Mussbacher
and Jörg Kienzle

T 12 Multi-Level Modeling with Melanie
Colin Atkinson, Bastian Kennel and Ralph Gerbig


T1
The Theory and Practice of Modeling Language Design
Speaker Bran Selic
Malina Software Corp.
Date & Time
Mon, Oct 1, 09:00 - 12:30
Room Hall Freiburg I
Abstract Model-based software engineering (MBSE), while not a panacea, has demonstrated its effectiveness in alleviating some of the most critical design issues in developing complex software systems. This tutorial focuses on a vital component of MBSE: the design of modeling languages and related technologies including model transformations. In contrast to traditional programming languages, whose primary purpose is to specify implementations such that they can be realized by a computer, modeling languages must satisfy a broader set of objectives, since the role of models typically extends beyond specification. This imposes additional challenges for language designers, beyond what is required for programming language design.
The tutorial is divided into 4 parts: (1) A critical introduction to MBSE, which provides the context for modeling languages (2) The theory and practice of modeling language design (i.e., key issues, principal design dimensions) with examples, (3) Practical methods for formal specification of modeling languages (metamodeling, language design patterns, etc.), and (4) A review of model transformation technologies and related issues, including model-to-model and model-to-text transforms. Standard widely-used modeling languages, including EMF, UML, and MOF, as well as some domain-specific languages are used to illustrate both good and bad design practices.

PREREQUISITES:
Knowledge of at least one modeling language such as UML. Experience in applying such a language is a strong asset, but is not mandatory.

Keywords

Modeling languages, model-based engineering, model-driven development, Model-Driven Architecture, model transformations, domain-specific languages, meta-modeling, automatic code generation


T2 From Model Editors to Modelling Tools: Operationalizing Modelling Methods with ADOxx
Speaker

Dimitris Karagiannis, Hans-Georg Fill, Srdjan Zivkovic and Wilfried Utz
Knowledge Engineering research group,
Faculty of Computer Science at the University of Vienna

Date & Time
Mon, Oct 1, 09:00 - 12:30
Room Hall Freiburg II
Abstract A growing number of groups emphasize on developing individual modelling languages, in addition to existing standard ones for a variety of application domains. Domain orientation allows modellers to express models in a terminology that belongs to the specific application domain which they address. To gain true benefits of domain-specific modelling and in particular of developed models as part of such efforts, dedicated tool support that provides the required functionality is needed.
After an introduction to meta-modelling platforms that claim to provide capabilities for developing modelling tools based on the notion of a domain specific modelling language (DSML), the tutorial explains the theoretical concepts and their practical implementation using ADOxx. Based on experience gained from research projects we investigate on meta-modelling concepts for realizing modelling methods constituents by introducing their operationalization through:
a) conceptualization: the design of fundamental concepts, relationships in between and properties adhering to them of the modelling method results in implementation requirements,
b) tooling: tool usability capabilities and modelling method requirements are implemented using ADOxx functionality, and
c) deployment: the implemented modelling method is configured and packaged in a modelling tool.
This tutorial enables the participants to shift their modelling methods from pure model editing to full-fledged tooling to further raise the benefits of modelling activities.
Keywords Meta-Modelling, Modelling-Languages and -Methods, Meta Modelling Frameworks and Platforms, Implementation of Domain-Specific Modelling Language


T3 Next-Generation Model-based Variability Management: Languages and Tools
Speaker

Mathieu Acher
INRIA / University of Rennes I / University of Namur

Patrick Heymans
PReCISE Research Centre, University of Namur
INRIA Lille-Nord Europe, Université Lille

Philippe Collet
Université Nice Sophia Antipolis

Philippe Lahire
Université Nice Sophia Antipolis

Date & Time Mon, Oct 1, 09:00 - 12:30
Room Hall Grenoble
Abstract Variability modelling and management is a key activity in a growing number of software engineering contexts, from software product lines (SPLs) to dynamic adaptive systems. Feature models are the defacto standard to formally represent and reason about commonality and variability of a software system.
This tutorial aims at presenting next generation of feature modeling languages and tools, directly applicable to a wide range of model-based variability problems. The languages and tools have already been applied in practical contexts (industrial and academic), in different application domains (printers, semi-conductors, medical imaging, video surveillance, etc.) and for various purposes (extraction of feature models from legacy software artifacts, document management, SPL evolution, management of multi SPLs and supply chains, validation of SPLs, large scale configuration of feature models, etc.)
Participants will learn the principles and foundations of languages (TVL and FAMILIAR) and
tool-supported techniques dedicated to the model-based management of variability. At the end of the tutorial, attendees should be able to reuse and combine them in practical or academic contexts.

PREREQUISITES:
Attendees, being industrial practitioners or academics, may have basic knowledge about software product lines and variability, but it is not required. The tutorial targets both beginners and advances.
Keywords Feature Models, Model Management, Variability Modelling, Automated Reasoning, Language, Model Composition and Differences


T4 How to implement Domain-Specific Modeling Languages: Hands-on
Speaker Steven Kelly
MetaCase
Date & Time Mon, Oct 1, 14:00 - 17.30
Room Hall Freiburg I
Abstract A horrible lie exists in our industry today: it says that defining a graphical DSL is difficult and time-consuming. In this tutorial, we will lay bare this fallacy and demonstrate how simple and quick it is to create domain-specific modeling languages and their generators. Using a hands-on approach you will define several modeling languages and generators within a few hours, learning principles and best practices proven in industrial experience in domains such as telecom, consumer electronics and home automation.
The tutorial teaches you and trains you in the practical, repeatable steps to invent and implement your own modeling language. The language definition process reveals the characteristics of modeling languages that enable truly model-driven engineering in which working code is generated from models:
- Modeling language based on the concepts of problem domain rather than solution domain (code)
- Scope of the language narrowed down to a particular domain
- Language minimizes the effort needed to create, update and check the models
- Language supports communication with users and customers
At the end of the tutorial you will have implemented several versions of the language, each time raising the level of abstraction closer to the problem domain.

PREREQUISITES:
Participants should have experience on using at least one modeling and/or code generation tool. Experience with metamodeling tools or language workbenches is not needed.
Keywords Language workbench; DSL design; language evolution; concrete syntax; code generation


T5 Empirical Studies in Software Engineering and Software Modeling
Speaker

Michel Chaudron
Leiden University

Marcela Genero
University of Castilla-La Mancha

Lars Pareto
Chalmers University

Date & Time Mon, Oct 1, 14:00 - 17.30
Room Hall Freiburg II
Abstract

The objective of this tutorial is to explain the basics of empirical research in software engineering in general and how to integrate this into research that relates to software modeling. The tutorial will cover:

-basics of empirical software engineering (What is it? Why is it relevant to the MODELS-community?).
- We will briefly discuss different empirical research strategies and focus on experiments and case studies.
- we will point out guidelines and key literature that exist for doing different kind of empirical studies.
- we will present some empirical studies that have been presented at MODELS and share the lessons learned (do's and dont's).
- time will be reserved to discuss how to design empirical studies for topics proposed by attendants.
The tutorial should be of interest to researchers in the MODELS-community (both lecturers and ph.d. students) that want to learn how to design empirical studies in support of their modeling-related research.

PREREQUISITES:
register intention to participate

Keywords Empirical Studies in Software Modeling, Experiment, Case Study


T6 The "Physics" of Notations: A Scientific Approach to Designing Visual Notations for Model Driven Development (MDD)
Speaker Daniel Moody
Ozemantics Pty Ltd
Date & Time Mon, Oct 1, 14:00 - 17.30
Room Hall Grenoble
Abstract

Visual notations form an integral part of the “language” of model driven development (MDD): virtually all modelling notations use diagrams as the primary basis for documenting and communicating models. For example, UML, the international standard language for modelling software systems, consists of 13 related visual notations. Currently, visual notations are designed in an ad hoc and unscientific manner. Decisions about visual representation are typically made in a subjective way, without reference to theory or empirical evidence. The reasons for choosing particular symbols to represent semantic constructs are generally shrouded in mystery. The aim of this tutorial is to establish a scientific basis for visual notation design: to help it progress from a “craft” (as it currently exists) into a design discipline. It defines a set of principles for designing cognitively effective visual notations: notations that are optimised for human communication and problem solving.
Importantly, these principles are evidence based: they are based on theory and empirical evidence drawn from a wide range of fields. They also rest on an explicit theory of how and why visual notations communicate. Together the principles provide a scientific basis for evaluating, comparing, and constructing visual notations, which has previously been lacking in the MDD field.

In this tutorial we pay explicit attention to methods for involving industry professionals as partners/participants in empirical studies.

PREREQUISITES:
Basic knowledge of modeling

Keywords Modelling, analysis, diagrams, communication, visualisation, visual syntax, concrete syntax, cognitive factors


T7
Applying Model Driven Engineering Technologies in the Creation of Domain Specific Modeling Languages
Speaker Bruce Trask and Angel Roman
MDE Systems Inc.
Date & Time Tue, Oct 2, 09:00 - 12:30
Room Hall Freiburg I
Abstract Model Driven Engineering (MDE) brings together multiple technologies and critical innovations and formalizes them into the next wave of software development methods. This tutorial will cover the basic patterns, principles and practices of MDE. The three main MDE categories include the development of Domain Specific Languages (DSL), Domain Specific Editors (and Views), and Domain Specific Transformation Engines or Generators. Expressed in terms of language development technology, these mirror the development of the Abstract Syntax, Concrete Syntax and Semantics of a new Domain Specific Language. This tutorial will cover the basic effective patterns, principles and practices for developing these MDE software artifacts. The tutorial will show how to apply these concepts as effective means with which to both raise levels of abstraction and domain specificity and thus increase power and value of tools and languages that allow developers to tackle the complexities of today's software systems. It will also show how to effectively leverage abstraction without sacrificing the ability to robustly and precisely refine these abstractions to solve complex real world problems. To show these patterns and principles in action, this tutorial will cover the details of how to leverage MDE Language Workbenches and frameworks in support of robust software development.

PREREQUISITES:
Basic understanding of abstraction, refinement and models.
Keywords Model Driven Engineering, Abstraction, Refinement, Domain Specific Modeling, Languages, Generative Programming


T8
Processing Simulink Models with Graph Rewriting-Based Model Transformation
Speaker

Péter Fehér
Department of Automation and Applied Informatics, Budapest University of Technology and Economics

Pieter J. Mosterman,
MathWorks

Tamás Mészáros,
Department of Automation and Applied Informatics, Budapest University of Technology and Economics

László Lengyel,
Department of Automation and Applied Informatics, Budapest University of Technology and Economics

Date & Time Tue, Oct 2, 09:00 - 12:30
Room Hall Freiburg II
Abstract Modern model transformation approaches are becoming increasingly valuable in software development because of the ability to capture domain knowledge in a declarative manner. This enables various steps in the software development to be specified separate from one another with apparent advantages such as reuse. In embedded system design, the computational functionality that is ultimately embedded moves through a series of design stages where different software representations are used. For example, before generating the code that is to run on the final target, code may be generated that includes additional monitoring functionality. In this tutorial, a model as designed with the de facto tool for control system design, Simulink®, is used as the starting point to apply model transformations for embedded software design purposes. It will be shown how an industry strength product such as Simulink can benefit from the use of graph rewriting model transformations. Two specific graph rewriting-based model transformations that perform part of the "model compilation" of a Simulink model are presented. These transformations are defined and executed in the Visual Modeling and Transformation System. During the presentation we emphasize the co-operation of the two systems and the main properties of the transformations.
Keywords Simulink, Model Transformation, Visual Modeling and Transformation System, Sorted List, Data Type Propagation, Hindley-Milner algorithm


T9 Category Theory and Model-Driven Engineering: Beyond formal semantics
Speaker

Zinovy Diskin
Network for Engineering of Complex Software-Intensive Systems for Automotive Systems (NECSIS), McMaster University
Generative Software Development Lab, University of Waterloo

Tom Maibaum
Network for Engineering of Complex Software-Intensive Systems for Automotive Systems (NECSIS), McMaster University

Date & Time Tue, Oct 2, 09:00 - 12:30
Room Hall Grenoble
Abstract There is a hidden intrigue in the title. Category Theory(CT) is one of the most abstract mathematical disciplines, nicknamed "abstract nonsense" during its early history. MDE is a recent trend in software development industrially supported by standards, tools, and a "new silver bullet" hype. Surprisingly, categorical patterns turned out to be directly applicable to mathematical modeling of structures appearing in everyday MDE routines. Model transformation and synchronization, model differencing and merging, and other model management scenarios can be seen as executions of categorical specifications.
The tutorial aims to elucidate a claim that relationships between CT and MDE are more complex and richer than is normally assumed for "applied mathematics". CT provides a toolbox of design patterns and principles for MDE, whose added value goes far beyond such typical applications as formal semantics for a language, or formal analysis and model checking. Two "case studies" (categorical foundations for heterogeneous multimodeling, and for bidirectional model transformations) should detail and justify the claim.

PREREQUISITES:
The audience is not assumed to have any knowledge of category theory, nor be experienced in mathematical modeling of software artifacts.
Keywords Model-driven engineering, mathematical modeling, category theory


T10 Language Workbenches, Embedded Software and Formal Verification
Speaker

Markus Voelter
independent/itemis

Daniel Ratiu
Fortiss

Date & Time Tue, Oct 2, 14:00 - 17.30
Room Hall Freiburg I
Abstract Domain Specific Languages play an increasingly important role in model-driven software development. As the tasks addressed with DSLs become more complex, DSLs must become more sophisticated and the language workbenches more powerful. In particular, they have to support composition and extension of languages, DSL debugging as well as the flexible combination of textual, tabular and graphical notations.
In this tutorial we show how the open source JetBrains MPS language work-bench addresses these challenges based on mbeddr, an open source, extensible IDE for embedded software development. mbeddr supports modular, incremental extension of C, debugging of extensions on DSL level, graphical visualizations as well as formal program analysis. To this end, mbeddr integrates an SMT solver and a model checker directly into the IDE. By extending C with suitable abstractions, programs become analyzable with these tools.
The tutorial is mostly based on demos, we will use only few slides. Participants will be inspired regarding the power of language workbenches as well as the usefulness of language engineering for building rich development environments and for incrementally integrating formal analyses in the development process. Although this tutorial uses embedded software as the example domain, the tutorial is not targetted to embedded software developers.
Keywords domain-specific languages, language composition and extension, code generation, formal verification, embedded software development


T11 Concern-Driven Development: Tool-supported Transformation of Requirements Models to Design Models
Speaker

Gunter Mussbacher
Department of Systems and Computer Engineering, Carleton University

Jörg Kienzle
School of Computer Science, McGill University

Date & Time Tue, Oct 2, 14:00 - 17.30
Room Hall Freiburg II
Abstract While many aspect-oriented modeling languages have been developed for requirements and design activities, the integration of these languages has received far less attention. However, these languages need to work together to truly capitalize on benefits promised by concern-driven development (CDD), i.e., improved productivity, reusability, and maintainability when concerns are encapsulated across software development phases. We present a tool-supported approach for the development of reactive systems based on the automated transformation of aspect-oriented workflow models at the requirements level into aspect-oriented design models. The presented approach enables practitioners to use the right modeling language for the right modeling task, enables encapsulation of concerns across these phases, and hence represents a first step toward an end-to-end methodology for CDD.

The tutorial uses a fully developed example and a hands-on exercise to demonstrate with the AoURNtoRAM tool how (i) a requirements model (described with the Aspect-oriented User Requirements Notation) is automatically transformed into a design model (described with Reusable Aspect Models) and (ii) how design-specific elements in the design model are subsequently completed.

AoURNtoRAM Tool Installation Instructions

PREREQUISITES:
Participants are assumed to have average modeling skills, i.e., they are already familiar with or working with software modeling techniques. Some general experience in concern-oriented modeling is an asset but not required as we will introduce the essential concepts in this area. Participants are assumed to have an interest in model-driven development (MDD), concern-driven development, model transformation from requirements models to design models in the presence of crosscutting concerns, MDD tools for model transformations that take concerns into account, and improved concern-aware modeling at different abstraction levels.
Keywords Model Transformations, Model-Driven Development, Concern-Driven Development, Aspect-oriented User Requirements Notation (AoURN), Reusable Aspect Models (RAM), Modeling Tools.


T12 Multi-Level Modeling with Melanie
Speaker Colin Atkinson, Bastian Kennel and Ralph Gerbig
Software Engineering Group,
University of Mannheim
Date & Time Tue, Oct 2, 14:00 - 17.30
Room Hall Grenoble
Abstract

Multi-level modeling based on deep instantiation has attracted growing interest over the last few years as a potentially better way of creating and organizing models, but the "jury is still out" on whether it delivers the benefits that its proponents claim. One of the main reasons why the debate has taken so long to resolve is that there has never been a mature tool for graphical, multi-level modeling that could be compared to traditional OMG and EMF based modeling tools. This tutorial introduces a new tool, Melanie, that aims to rectify this situation. Melanie is an EMF-based tool for multi-level that provides a fully featured graphical editor along with a rich set of model checking and reasoning services. The tutorial will first introduce the Pan-level Model (abstract syntax) and Level-agnostic Modeling Language (concrete syntax) that underpin Melanie and then demonstrate how a number of classic modeling problems and examples can be modeled using the tool. By the end of the tutorial, attendees will have a much clearer picture of the pros and cons of multi-level modeling and of the benefits the Melanie tool has to offer.

PREREQUISITES:
The only prerequisites are familiarity with UML or OWL based modeling.

Keywords

Multi-level modeling, meta-modeling, domain specific languages, modeling tool, level-agnostic modeling language