Following the tradition of previous conferences, MODELS 2020 will host tutorials as part of its satellite events on October 16 to 20, 2020. Due to the COVID-19 situation, the conference will run fully virtually.

Tutorials provide intensive overviews on topics in the area of model-based software and systems engineering ranging from modeling methodologies and research methods through new modeling tools and technologies to thoughts on the past, current, and future development of the modeling discipline.

Audience

Tutorials target an audience of practitioners, researchers (academic and industrial), students, and developers familiar with, and already working with, modeling techniques. The target audience typically has a strong interest in Model-Driven Engineering (MDE), including work on improving and evolving modeling languages (such as UML or DSLs), developing sophisticated MDE tool support, and using MDE to develop / test / reverse / maintain complex systems. Potential attendees may also be interested in how modeling has been applied effectively in specialized domains (e.g., in the automotive industry), and in learning about successful uses of MDE methods in real-world applications.

Topics

The following themes are examples of what is considered relevant for tutorials:

• Modeling techniques for specific domains (e.g., automobile, cyber-physical and hybrid systems, Industry 4.0, Internet of Things …)
• Modeling methodologies and model-oriented processes (e.g., for agile modelling or modelling at scale)
• AI in modelling (including search*based approaches, machine learning, planning, or flexible modelling)
• Presentation of new tools or new versions of old tools (e.g., modeling tools, language workbenches, model transformation languages, model verification tools, model execution tools)
• Dissemination of project results from industry-related projects
• Teaching of model-driven software development
• Research methods in MD* (Model-Driven Development (MDD), Model Driven Engineering (MDE), Model Driven Software Development (MDSD), etc.)
• Modeling for re-engineering and legacy evolution
• Empirical studies in the context of modeling
• User experience in model-based software engineering
• Practical experiences of general interest
• General topics of interest to young researchers, like presentation skills or research methodologies

Furthermore, we also welcome submissions related to this year’s theme: modeling in the era of data.

Tutorials are intended to provide independent instructions on a topic of relevance to the audience described above. Therefore, no sales-oriented presentations will be accepted. Tutorials relating to commercial tools or involving the use of commercial tools may be accepted, but will be subject to closer scrutiny, including possible approval of presentation slides. Potential presenters should keep in mind that there may be quite a varied audience, including novice graduate students, seasoned practitioners, and specialized researchers. Tutorial speakers should be prepared to cope with this diversity.

Proposal Guidelines

Proposal Contents

All submissions must be in English and adhere to the IEEE formatting instructions . The submission must include the following information in the indicated order:

• Title
• Presenters: Name, affiliation, contact information, and short bio.
• Authors of the proposal or tutorial material, who are not going to be presenting, may be listed, but must be listed last with a footnote “Author only; will not be presenting”.
• Abstract (maximum of 200 words) If accepted, the abstract will be used to advertise the tutorial. Thus, the abstract should clearly highlight the goals of the tutorial and the skills that participants will acquire.
• Keywords (at least 5 keywords)
• Proposed length (suggestion: up to 1.5-2 hours)
• Level of the tutorial: beginner/introduction or advanced Target audience and any prerequisite background required by attendees to be able to follow the tutorial (beyond average modeling skills)
• Description of the tutorial and intended outline (maximum of 4 pages)
• Novelty of the tutorial
• List offerings of similar tutorials at previous editions of the MODELS conference or other conferences, and discuss the differences with respect to the current proposal.
• Required infrastructure: Explicitly specify the adaptations and actions you intend to do in order to make the tutorial suitable for a virtual environment.
• Sample slides (minimum of 6 slides, maximum of 25 slides)
• Supplementary material (optional)

Proposals must be submitted electronically in PDF format through the MODELS 2020 Tutorials EasyChair submission page.

Review Process

The Tutorials Selection Committee will review each submitted proposal to ensure high quality, and select tutorials based on their anticipated benefit for prospective participants and their fit within the tutorial program as a whole. Factors to be considered also include: relevance, timeliness, importance, and audience appeal; effectiveness of teaching methods; and past experience and qualifications of the instructors. The goal will be to provide a diverse set of tutorials that attracts a high level of interest among broad segments of the MODELS participants.

Note that, as per ACM policy, tutorials are not included in the proceedings of the conference companion.

Compensation

As in previous years, participants will pay a single satellite fee, which will cover both tutorials and workshops. This permits unifying the treatment of workshops and tutorials, and it makes tutorials more attractive to attendees. Under this scheme, tutorial presenters will not receive monetary compensation, and will have to pay their own registration to the satellite events. By submitting a tutorial proposal, the presenter accepts that there will be no compensation for giving the tutorial if accepted and that the registration fees for the instructors have to be funded by the instructors themselves. The benefit to the presenter is the opportunity to extend their sphere of influence to the MODELS community.

[T1] Domain-Specific Languages with JetBrains MPS

Organizer: Mikhail Barash

A Domain-Specific Language (DSL) is a programming language specifically designed for a particular (narrow) domain. DSLs can increase the productivity of programming in many ways: by offering concise programming notations, reducing the number of defects, improving communication between developers and business experts, and so on. DSLs as part of software development pipelines are slowly becoming more and more popular. One reason for the increased popularity is tooling: modern language workbenches – tools to define DSLs together with their IDEs – make developing new languages cost-effective and fun. In this tutorial, I will talk about language workbench JetBrains MPS. It supports projectional (structured) editing, which is an alternative to mainstream text-based editing that allows overcoming the limits of language parsers and enables domain experts to program. JetBrains MPS allows defining DSL editors supporting textual, tabular and graphical notations. During the tutorial, the participants will implement an IDE for a trivial Entities Language. The tutorial is intended for those interested in implementing domain-specific languages, and requires basic programming skills in Java or another object-oriented programming language.

[T2] Graph Transformation for Software Engineers

Organizers: Reiko Heckel and Gabriele Taentzer

Graphs are used to model a wide variety of structures in computer science and beyond. In software engineering, it is we use graphs for modelling structures such as software architectures, class and object structures, control or process flow. As software systems evolve, these structures graphs may change. If graphs represent object structures at run time, for example, changing these graphs can model system behaviour. Graph transformation is an approach to specify graph changes in a rule-based way. Despite an established record in addressing a range of problems relevant to the MoDELS community, adoption of graph transformation techniques outside their core community has often been limited by a steep learning curve compounded by the fact that much of the literature on graph transformation has not been written for an audience of modellers and software engineers. This tutorial addresses the lack of generally accessible material by providing a systematic but non-technical introduction to the core concepts, modelling styles and analysis techniques of graph transformation with selected applications to model-based software development and model-driven language engineering. This tutorial is based on the recent book on “Graph Transformation for Software Engineers” by Heckel and Taentzer. A pdf authors copy can be provided to participants free of charge.

[T3] Advanced Model-Oriented Programming Using Umple

Organizer: Timothy Lethbridge

Umple is celebrating 10 years as an open source modeling and code generation technology. In this tutorial, we will introduce the technology to those new to Umple and also demonstrate some of its newer features. Umple is designed to allow modeling abstractions such as state machines and associations to be blended seamlessly with code in multiple programming languages. Umple also incorporates mixins, product line technology, traits, tracing, generation templates, and aspects. All of these capabilities work synergistically with models, with each other and with traditional code. Umple can be used with any IDE, since it has been designed to have few dependencies. For exploratory use, only a browser is needed. For more serious use a JVM (V8-14) is required. A Docker image is also available. The tutorial will be hands-on. Participants will build some small applications involving state machine models, feature models and aspects. Since Umple is written fully in itself, we will also demonstrate how an open-source, model-driven, test-driven agile project can be managed.

[T4] Model-based Handling of Polyglot Database Applications

Organizers: Noa Roy-Hubara and Arnon Sturm

Over the years, new database models and DBMSs emerged to cope with the evolving requirements from such systems, and the new data. The variety of DBMSs and their models have led to using a hybrid approach, called polyglot persistence, in which each type of data is handled by the most suitable database technology. However, the selection and design of the new models and multimodel database gain limited attention resulting in either model-specific design approaches or design based on best practices. In this tutorial we review the stat-of-the-art database design methods, emphasizing their underlying models and analyze these methods considering various desired properties we devised. We further provide insights regarding the selection of the proper databases and introduce a model-based approach for performing that selection. To complete the flow, we further present a prototype of a model-based programming framework in which the application development is agnostic to the database technology, though utilize the appropriate one.

[T5] Assurance of Complex Software-Intensive Systems using WF+

Organizers: Nicholas Annable, Mehrnoosh Askarpour, Zinovy Diskin and Alan Wassyng

Safety assurance for safety-critical systems, such as autonomous vehicles, is of utmost importance, but is often difficult and expensive. Given the complexity and intensity of such systems, we believe it is time for the model-driven engineering community to come up with new solutions for assurance case development and management, which offer more automation, reusability, and comprehensiveness. We, at Mcscert team, propose WorkFlow+ (WF+), a safety assurance development framework that fosters efficient and incremental assurance by modeling (i) processes, (ii) data, and (iii) constraints (leading to arguments) as three distinctive but interrelated workflows; a WF+ model is an argument flow over an integral data and process flow. Even though WF+ is still a young contribution, it proved itself beneficial in an industrial project we’ve been recently working on. In particular, we used WF+ for the safety analysis of safety-critical components of autonomous vehicles and modeling the indications in ISO 26262. Based on feedback from our partners in the project, WF+ is able to systematically model the ad-hoc industrial safety engineering processes and features better traceability upon change and modifications in systems, which is very often the case in realistic settings. We are currently implementing an EMF-based modeling Eclipse plugin to make WF+ more broadly used by the safety engineering community. More publications on the matter will come out soon.

[T6] Introduction to the OMG Systems Modeling Language (SysML) Version 2

Organizer: Ed Seidewitz

This tutorial will introduce the OMG Systems Modeling Language Version 2 (SysML v2). SysML v2 is the successor to SysML Version 1, which has been the standard language for model-based systems engineering since 2017. Unlike its predecessor, SysML v2 is not a profile of UML, but is a modern, formally grounded, extensible modeling language with both a textual and graphical notation. It is tailored for systems modeling, but built on a syntactic and semantic kernel that provides a foundation for interoperability with other related modeling languages. The tutorial will demonstrate the language using the pilot implementation developed by the SysML v2 Submission Team (SST). The SST is a joint team of over 70 industry, academic and government organizations that has been working on SysML v2 since the OMG issued the Request for Proposals for it in December 2017. The SST has now completed its initial submission of SysML v2 to OMG, and is making its pilot implementation publicly available as open source. Work is continuing toward a revised submission next year. Moreover, current challenges, future steps, and also the undergoing toolchain implementation will be discussed.

[T7] Big Data Polystore Management with TYPHON

Organizers: Francesco Basciani, Marie-Saphira Flug, Loup Meuricek, Fulya Horozal, Tijs van der Storm, Sebastian Scholze and Athanasios Zolotas

The need for levels of availability and scalability beyond those supported by relational databases has led to the emergence of a new generation of purpose-specific databases grouped under the term NoSQL. In general, NoSQL databases are designed with horizontal scalability as a primary concern and deliver increased availability and fault tolerance at a cost of temporary inconsistency and reduced durability of data. To balance the requirements for data consistency and availability, organisations increasingly migrate towards hybrid data persistence architectures comprising both relational and NoSQL databases. The consensus is that this trend will only become stronger in the future; critical data will continue to be stored in ACID (largely relational) databases while non-critical data will be progressively migrated to high-availability NoSQL databases. Designing and deploying a hybrid data persistence architecture that involves a combination of relational and NoSQL databases is a complex, technically challenging and error-prone task. In this tutorial we will present a model-based methodology developed in the context of the EC-funded H2020 TYPHON project (typhon-project.org) for designing, developing, querying and evolving such scalable architectures for persistence, analytics and monitoring of large volumes of hybrid (relational, graph-based, document-based, natural language, etc.) data, in a systematic and disciplined manner.