MODELS '18- Proceedings of the 21st ACM/IEEE International Conference on Model Driven Engineering Languages and Systems: Companion Proceedings

Developing model transformations can be a complex task and as such advanced reuse mechanisms are increasingly recognised as necessary for increasing both development productivity and quality of model transformations. Creating a new transformation by chaining existing ones is one of the possible ways to reuse existing transformations. However, chaining transformations can be an error prone and strenuous task especially in case of multiple potential chains.

In this paper the CITRIC tool is presented as a solution to mitigate the problem of characterizing the multitude of transformation chains that can be defined by composing existing model transformations to bridge source and target metamodels that are of interest for the modeler. The tool is based on well-established algorithms, and it is able to support modelers when multiple transformation chains are available. The optimal chain is automatically selected based on two quality criteria i.e., metamodel coverage and information loss.

Although there are many city journey planners already available in the market and involving various transportation services, there is none yet that allows city mobility operators and local government municipalities to be an active part of the city's mobility.

In this demonstrator, we present our first attempt towards multi-view based modelling of adaptive and multimodal city journey planners. In particular, by exploiting Model-Driven Engineering (MDE) techniques, the different stakeholders involved in the city mobility are able to provide their own updated information or promote their own challenges at higher levels of abstraction. Such information is then automatically translated into code-based artefacts that implement/ensure the desired journey planning behaviour, notably to filter travel routes and to make the city mobility more sustainable.

The journey planner prototype, implementing the proposed solution, is demonstrated in the context of Trento city mobility. A supporting video illustrating the main features and a demonstration of our solution can be found at: https://youtu.be/KM21WD2dQGs, while the related artefacts and the details on how to create your own prototype are available at the demo GitHub repository, reachable at https://github.com/modelsconf2018/artifact-evaluation/tree/master/bucchiarone.

Model Driven Engineering (MDE) is a methodology that aims to simplify the process of designing complex systems, by using models as an abstract representation of the underlying system.

This methodology allows domain experts to more easily focus on system design, where their knowledge is more useful, without having to work with the system implementation complexities. Search Based Model Engineering applies MDE concepts to optimisation problems. The goal is to simplify the process of solving optimisation problems for domain experts, by abstracting the complexity of solving optimisation problems and allowing them to focus on the domain level issues..

In this tool demostration we present MDEOptimiser (MDEO), a tool for specifying and solving optimisation problems using MDE. With MDEO the user can specify optimisation problems using a simple DSL. The tool can run evolutionary optimisation algorithms that use models as an encoding for population members and model transformations as search operators. We showcase the functionality of the tool using a number of case studies. We aim to show that with MDEO, specifying optimisation problems becomes a less complex task compared to custom implementations.

Placer is a model-based tool that, given a model of heterogeneous (or at least multi-core) hardware and a task-based complex software, finds a mapping of the software tasks on the various processing elements of the hardware, together with a routing of the transmissions on the available busses, and provides a schedule for the tasks and transmissions. The mapping can minimize either the run time, energy consumption, or both in a multi-objective fashion. The tool combines an Eclipse front-end and a web-service placement back-end based on the OscaR constraint programming library. The tool demonstration illustrates how to build the task model, perform the analysis and possibly iterate to improve the placement.

The systematic analysis of related work is an important part of every research project. Surprisingly, especially in computer science, this activity is typically performed manually. Whilst in other disciplines fully automated analysis approaches exist, the lack of a reasonably complete, queryable and free-to-use literature catalog for computer science requires computer scientists to manually retrieve, merge and analyze literature from different catalogs. Although manual literature retrieval is enforced by the current main publishers, tool support to merge and cleanse literature found in different catalogs as well as to analyze the results is possible and needed. The systematic literature review toolkit, an Eclipse Rich Client Platform application leveraging the Eclipse Modeling Framework, aims to provide this support. Currently, four main features are supported: simple literature filtering, design of a taxonomy, classification of literature and analysis of the classification by generated diagrams. The tool is available online: https://github.com/sebastiangoetz/slr-toolkit

Large-scale cyber-physical systems are co-engineered, especially in safety-critical industries, by various specialists within an organization and, increasingly, across organizations. The collaborative aspect of the process is facilitated by hosting engineering artifacts in model repositories. In order to validate the adherence to design rules, perform change impact analysis across projects, generate reports etc., engineers specify model queries and evaluate them using query engines, traditionally available in client modeling tools.

In this paper we introduce IncQuery Server for Teamwork Cloud (IQS4TWC), a standalone middleware service that connects to Teamwork Cloud model repositories, and builds on Viatra Query to provide fast querying over their content. The new server-side solution provides advanced features including single-model ad-hoc queries as well as repository-wide change impact analysis (correlating projects across branches and revisions); access to version snapshots as well as queries on the latest state; and a range of performance fine-tuning options (such as elasticity and in-memory indexes) to achieve high scalability.

Metamodels are used in model-driven engineering and model-driven software development to define domain specific languages. Over time, they tend to evolve and grow in complexity to encompass new features. If a modular approach is not taken into account and metamodels are extended intrusively, they can become difficult to maintain and to extend. With the increased complexity, it often becomes even more challenging to modularize the metamodels. However, even though modularity is an established concept in the realm of software engineering, existing metamodeling tools barely address the challenges of modular metamodeling.

In this work, we approach the problem from a graphical perspective. We propose a tool that assists the modeler in designing and refactoring metamodels in a modular way. It allows the modeler to explicitly organize metamodels in a layered architecture where each layer has a certain degree of abstraction. The tool detects cyclical dependencies between metamodels and violations to layering and provides key insights about how metamodels depend on each other. By that means, modular metamodeling is encouraged and modularizing metamodels is greatly facilitated.

Language engineering is a collaborative endeavor with several people creating and using the modeling languages and related generators. We describe key features of the MetaEdit+ multi-user version that support collaborative language engineering, evolution and use. Several language engineers can create and refine the same modeling language at the same time, see each other's changes, and version language definitions to version control systems. A key characteristic of MetaEdit+ is continuous integration of language definitions and of models created with the languages.

This paper provides an overview of SimGen, a prototyping tool which aids in the creation of 3D simulations for embedded systems testing. SimGen relies on a domain specific language to describe the components of the simulation and the communication protocol used to interface with them. A game engine called Unity is used to power the 3D environment in which the simulation takes place. The prototyping tool generates the necessary scripts to fully build the simulation within the Unity environment. By using the power of the Unity environment with the simplicity of the domain specific language, users are able to create simulations customized to their testing needs. The communication protocol between individual objects and the users application is defined by the user in the DSL and runs on TCP sockets for a general and easy to implement connection.

Demonstration video: https://youtu.be/4ROt2N6i6KA

Download link: https://github.com/PasternakMichal/SimGen.git

The importance of appropriate software design documentation has been well-established. Yet in industrial practice design documentation of large software systems is often out of date or entirely lacking in large part due to the effort required to produce and maintain useful design documents. While model-based design (mbd) partially addresses this problem, large complex models still require additional design documentation to enable development and maintenance. This paper introduces tool support for documenting the Software Design Description (sdd) of embedded systems developed using mbd with Simulink. In particular, the paper proposes a template for a sdd of a Simulink model. Then, the tool support we have developed for semi-automatic generation of sdds from the template is introduced. The tool support integrates MathWorks' Simulink Report Generator and our previously developed Signature Tool that identifies the interfaces of Simulink subsystems.

Reverse engineering GUI models from Android apps is important for model based techniques. We believe that the UI driven feature of Android makes it necessary to build GUI models with sufficient details in order to adequately capture the apps' behavior.

In this work, we make some effort in static extraction of GUI models for Android apps and our focuses include: (i) analyzing container components including Navigation-View, Fragment and RecyclerView; (ii) extracting constraint information, especially those related to window transitions; (iii) representing the analysis result with Interaction Flow Modeling Language (IFML) to visually present GUI elements of Android apps, so as to facilitate human comprehension and manual modification of the models.

Motivated by the system management concept of Integrated Modular Avionics (IMA), where the system is manually divided into a hierarchical structure of clusters of closely related system components, so called integration areas, we introduce a data mining-based approach to automatically calculate such integration areas or clusters. Thus, facilitating the modelling process by clustering software components with dense intercommunication, achieving in this way a reduced off-board intercommunication, once the software is mapped to the underlying hardware. Even though the idea emerged from the avionics domain, the proposed approach can be applied to other domains, e.g., automotive, as well.

Smart grids are the oncoming generation of power grids, which rely on information and communication technologies to tackle decentralized and intermittent energy sources such as wind farms and photovoltaic plants. They integrate physical, software and network technical domains. Therefore the design of smart grids is complex because of the various technical domains and modeling tools at stake. Simulation is very valuable to evaluate various behavioral assumptions, and cosimulation allows each designer to work on its part of the design, with its own tools and modeling language. However, the accuracy and the predictive value of the cosimulation depend on a proper integration of these models and on the correct synchronization of their execution. In our work, we propose an approach which rely on model driven engineering to maintain the consistency between all the models, through a DSL and model transformation techniques.

We present unified and extensible semantics for Behavioral Programming (BP). The presented semantics support a direct embedding of executable models in regular software systems. We further present BPjs --- a tool-set for executing, embedding, and verifying behavioral models, based on the proposed semantics. Being extensible, embeddable, and supporting verification, BPjs can serve as a common infrastructure for BP and executable modeling research.

This paper presents the evolution of teaching a holistic course on Model-driven Software Development based on analyzing and assessing of a set of related courses during the last ten years, taught both in Norway and the USA. The objectives of these courses are to demonstrate and teach the use of modeling tools through a holistic perspective, from business architecture, requirements, system architecture, software architecture, and to executable models that take advantages of platform-based development. An analysis of the courses from previous years resulted in a recommendation for a new setup for the courses in 2018, in turn, a further analysis of the experiences and results from the 2018 courses leads to a plan for improvements for the courses to be taught in future. The result is a complete enterprise architecture modeling approach education from business architecture to software architecture to functioning software.

Online and blended learning are employed by educators in a wide variety of fields, from literature to computer science, from medicine to astronomy. However, online and, specifically, MOOC and SPOC technologies are still not widespread in the field of conceptual modelling. The complex nature of conceptual modelling as a subject to be taught at the university level, as well as the increasing number of students, pose a certain challenge to the modern educators and call for a thorough review of the teaching methods, types of assessment and technologies used to support the learning process. In this paper, we provide an experience report on a redesigned master level university course on conceptual modelling, which employs blended learning approach. We investigate the aspects of students' behavior, performance and perception of the course, and reflect on the possibilities of transition from a SPOC in the context of blended learning to an exclusively online MOOC. This experience may provide valuable insights for the conceptual modelling educators planning to introduce blended or online learning and/or utilize formative assessment in their pedagogical activities.

Industry 4.0 and its international siblings envision revolutionizing manufacturing through integrating software-intensive systems from business plans to manufacturing systems to products and across the complete value-added chain. We observe a trend towards model-based systems engineering in the context of Industry 4.0, which requires finding a balance between modeling challenges and manufacturing challenges in educating software engineering students to become a vital part of this revolution. We conducted a project class on model-based systems engineering for Industry 4.0 to uncover the challenges in preparing the participating computer science students for playing a role contributing to the vision of Industry 4.0. To this end, we instrumented the class with a questionnaire and semi-structured interviews to understand the challenges and expectations of students on this topic. We report the results of both and lessons learned for future project classes on model-based systems engineering for Industry 4.0.

Model-based Software Engineering (MBSE) is now accepted as a Software Engineering (SE) discipline and is being taught as part of more general SE curricula. However, an agreed core of concepts, mechanisms and practices --- which constitutes the Body of Knowledge of a discipline --- has not been captured anywhere, and is only partially covered by the SE Body of Knowledge (SWEBOK). With the goals of characterizing the contents of the MBSE discipline, promoting a consistent view of it worldwide, clarifying its scope with regard to other SE disciplines, and defining a foundation for a curriculum development on MBSE, this paper provides a proposal for an extension of the contents of SWEBOK with the set of fundamental concepts, terms and mechanisms that should constitute the MBSE Body of Knowledge.

An achievement-driven methodology strives to give students more control of their learning with enough flexibility to engage them in deeper learning.

We observed in the course Advanced Software Design, which uses the achievement-driven methodology, that students fail to get high grades, which may hamper deeper learning. To motivate students to pursue and get higher grades we added gamification elements to the course.

To measure the success of our gamification implementation, students filled out a questionaire rating the enjoyment and motivation produced by the game. We built a statistical regression model where enjoyment and motivation explain 55% of the variation in grades. However, only the relationship between motivation and grade is significant, which implies that notivation drives the overall effect of the model. The results suggest that the more the students were motivated by the game, the higher their grades on the course (and vice versa). This implies that if gamification indeed motivates students, then it makes them go beyond what is expected.

Modelling techniques have been part of the software engineering practice for decades. Despite Model-Driven Software Engineering (Mde) being spread in the industry, effective teaching through meaningful use cases remains a challenge. Some guidelines and teaching experiences have been reported that either focus on the content of an Mde course, or on tooling environments designed for students. Furthermore, little emphasis has been put on the usability in the context of Software Language Engineering (Sle), which may lead to technically valid languages, but which are difficult to use. In this paper, we report on our attempt to combine a practical use case for Sle and a structured peer review focusing on the language usability and its tooling environment. By putting students in both the seats of language designers and users, we believe to empower students with suitable technical Sle skills as well as making them aware that a good software language requires more than theoretical validity to be adopted.

This paper describes our experience in constructing a new Domain-Specific Language course at the graduate level whose objectives is to reconciliate concepts coming from Language Design as well as Modeling domains. We illustrate the course using the reactive systems application domain, which prevents us to fall back in a toy example pitfall. This paper describes the nine stages used to guide students through a journey starting at low-level C code to end with the usage of a language design workbench. This course was given as a graduate course available at Université Côte d'Azur (8 weeks, engineering-oriented) and École Normale Supérieure de Lyon (13 weeks, research-oriented).

A role is a powerful modeling concept in software modeling. Beginners in modeling, however, find it difficult to understand the role concept. They often confuse the role concept with the is-a relationship (generalization). Therefore, we address the semantic difference between (natural) objects and roles in object-oriented modeling by using a new teaching approach - the R-CRC Card Method which is a role-based extension of the CRC Card Method. This work provides an introduction to this new approach and reveals results from a case study with 178 undergraduate students comparing both card methods. It is shown that the R-CRC Card Method is more suitable for analyzing an application domain and the identification of roles. Further study findings depict the effectiveness of the method for education by teaching students and support the R-CRC Card Method as a didactic tool for teaching the role concept in object-oriented modeling.

Understanding the experiences of instructors teaching modelling and model-driven engineering is of great relevance to determining how MDE courses should be managed in terms of content, assessment, and teaching methods. In this paper, we report the results of a survey of 47 instructors in this field. Questions address course content, tools and technologies used, as well as positive and negative factors affecting learning outcomes. We analyse the results and summarise key findings with the potential of improving the state of teaching and learning practices. The survey is a preliminary effort in giving a structured overview on the state-of-the-practice within teaching modeling and model-driven engineering (from the point of view of the instructor).

The prevalence of model-driven software engineering in industry combined with a personal interest in the topic led to the conception of a new course aimed at introducing students to topics related to modeling. This paper presents a retrospective examination of this course, including: a course overview, intra-student grade comparisons on topic-centered assessments, and student feedback regarding course topics and implementation. The paper provides sufficient detail of the course offering such that, if desired, readers could offer a course with similar goals, outcomes, and structure. Finally, specific lessons learned are presented in hopes of enabling future improvements to the course and as a warning to other academics should they begin to offer similar courses.

Experiments, case studies and surveys are part of the standard toolbox researchers use for validating their proposed educational tools and methods. Yet the breadth of such evaluations is often limited to one dimension such as assessing the effect on learning outcomes by means of experiments, or evaluating user acceptance and perceived utility by means of surveys. Besides a positive effect in the classroom, it is equally important that students transfer their knowledge to their working environment, which constitutes yet another evaluation dimension. The lack of a widely accepted validation method encompassing a broad set of dimensions hampers the comparability and synthesis of research on modelling education. This study adapts Kirkpatrick's model of training evaluation to the assessment of Technology Enhanced Learning (TEL), i.e. learning settings where the teaching is supported by means of didactic tools. The adaptation proposes concrete metrics and instruments for each of Kirkpatrick's model level. The adaption is demonstrated by means of a case study on a TEL environment for User Interface (UI) modelling that supports the learning UI design principles.

It is a commonplace in computer science education that abstraction is a key concept. In model-driven development in particular, we all understand that the power of models comes from the fact that a model is an abstract representation of something important about a system. As a community, we are sometimes conflicted about whether the ability to think abstractly - to generate "good" abstractions, and/or to use abstractions effectively - is innate, or can be taught. To whatever extent it can be taught, how is this best done? I will review the state of the art concerning these matters, relating it to my experience in teaching modelling to university students, and to my brief trials of teaching it to ten-year-old school children.

This paper gives an overview over a dissertation project in the area of design space exploration for distributed, embedded systems. As the engineering of distributed embedded systems is getting more and more complex due to increasingly sophisticated functionalities demanding more and more powerful hardware, automation is required in order cope with this rising complexity. Using a model based systems engineering approach enables design space exploration methods which provide such automations, given a formalization of the problem in order to be solvable e.g. by SMT solvers.

In this thesis we want to provide an automated synthesis of hardware topologies (E/E architectures) based on the functions which are deployed onto this topology and constraints and optimization objectives which are derived from the requirements of the system. The synthesis shall consider variability aspects (possible variants) of the hardware elements. Additionally, timing aspects of the deployed shall be regarded such that the solution of the synthesis is a hardware topology, a deployment of functions onto this topology and a schedule of these functions.

The thesis shall be evaluated by using an automotive industrial use case of realistic size.

The problem of integrating an existing formal verification tool in a given software specification tool arises repeatedly both in industry and academia. At present this task is executed in an ad-hoc manner and is time consuming. Moreover, interpreting the results of the verification to locate and fix the bug (by the human user) is implicitly complicated, hence, time consuming. In this work we draft a solution for reducing the complexity of these tasks and aim at reducing the time required to complete them. We sketch a framework formalizing the concepts required to execute these tasks in a modular fashion and implement a solution based on domain specific languages (DSLs) and parameterizable model transformations. We expect that the modularity of our framework will raise its potential to be reused. We plan on evaluating this work on a set of modeling environments and a set of verification tools.

Modern software systems are developed using multiple models to represent different properties of the system. Since these models contain dependent information, keeping them consistent is crucial for producing correctly operating software. This process can be automated with model transformations, and has been researched mainly for binary transformations that define consistency preservation for pairs of metamodels. If more than two metamodels are involved, the combination of several binary transformations leads to problems such as interoperability issues and occurring trade-off decisions. Therefore, we investigate these problems in multi-model consistency preservation in our thesis. We first analyze the interoperability of binary transformations that have been independently developed and derive patterns for non-intrusive transformation interoperability. Furthermore, we introduce an approach for decomposing consistency relations and concept metamodels that make relations explicit. This is supposed to reduce the necessity for trade-off decisions regarding challenges such as compatibility of dependent transformations and modularity of used metamodels and transformations, as well as comprehensibility and evolvability. The proposed benefit of our approach is that independently developed binary transformations can be combined, omitting interoperability issues without the necessity to know about each other, to achieve multi-model consistency. We will evaluate our approach with case studies from component-based and object-oriented software, as well as with industrial case studies for embedded automotive software and production systems.

High availability of automation systems is one of the main goals for the companies from all industrial branches. To achieve and maintain this high availability, the condition monitoring of the automation systems is an essential building block. However, as automation systems become increasingly equipped with numerous mechanical, electrical, and software components, creating a condition monitoring solution is becoming more and more challenging and requires knowledge from multiple engineering disciplines. Today, creating a condition monitoring solution is mostly based on the experience and preferences of the developers without a systematic and interdisciplinary method.

Today, methods and tools supporting an interdisciplinary development exist. However, they do not fully consider condition monitoring relevant information. In addition, tools that increase software productivity and ease the adjustment of condition monitoring software are lacking. The main goal of this paper is to narrow the condition monitoring expertise gap by proposing convenient, systematic, and automated techniques to support the development of condition monitoring solutions from their design to their implementation.

To achieve this goal, we propose an extension of the CONSENS systems engineering method to face issues caused in the design phase. By adopting a Model-Driven Development (MDD) approach, we propose a Domain-Specific Language (DSL) for condition monitoring that promotes increased understandability, and automation during the software implementation phase.

Unified Modelling Language (UML) has become the de-facto standard language for developing models of software system. During the past decades, many tools have been proposed to facilitate the task of developing UML-like models, specifically developing Class and State-Machine diagrams. Most of the tools have focused on addressing technical aspects (e.g., checking the semantics of the language) rather than the usability. The literature shows that tools' usability is a major barrier to the adoption of Model-Driven Engineering (MDE) in the industry. We hypothesize that the reason is a paucity of research on User Experience (UX) in the modelling community, and discuss that there are opportunities for further enhancements with respect to UX. We conducted a formative user study to observe, identify and understand the users' cognitive challenges when performing their tasks using modelling tools. The results of the study revealed that two of the most severe challenges of modellers when using modelling tools are: 1) Remembering the contextual information, and 2) Locating, understanding and fixing errors in the models. Our next steps are to propose solutions such as tooling features in order to alleviate the identified challenges and evaluate the effectiveness of our proposed solutions on users.

Most industrial software development processes rely on a variety of tools that are specialized in particular development tasks. As the number of modelling tools involved in a development process increases, handling the heterogeneity of model artefacts and interoperability between tools becomes a complex task. As traceability is mandated by regulations and standards, it has been one of the main drivers for the establishment of semantically rich relations between model artefacts in order to facilitate the generation of compliance evidence required for certification. While there are modelling tools that provide interoperability features with other modelling languages or tools, there is no rigorous and automated approach for capturing semantic relationships across heterogeneous modelling environments. We argue that having a structured, automated and technology-agnostic approach to declare the relationships between heterogeneous artefacts (e.g. through model mappings) can increase the maintainability of the model management operations and grant more flexibility to switch tools for any development task. In this work we propose an architecture that facilitates life cycle- and system- wide context-awareness in heterogeneous modelling environments and enables the automation of model management tasks through semantically rich relationships between heterogeneous model artefacts. For this purpose, we define context-awareness as the ability to capture and manage the frames of knowledge of the development process e.g. software architecture, testing artefacts, applicable standards, etc.

The fourth industrial revolution (Industry 4.0) strives for an optimized and flexible production process to reduce configuration costs. To achieve such a production process, first architecture-level decisions (i.e. deployment configuration, scheduling, etc.) are optimized. Following, these optimized architectural configurations are applied to dynamically reconfigure industrial control applications. To calculate software configurations, current research applies Design Space Exploration (DSE) techniques embedded into the IEC 61499 model-based approach. However, this research either applies simple and non-applicable constraints and objectives for real-life problems or considers architectural optimization solely at the design phase. Thus, reconfiguring industrial control applications is still an exhausting and manual task that requires production process' downtime.

In this Ph.D. thesis, I handle the automatically optimized reconfiguration of the industrial automation systems. In particular, I propose applying DSE to calculate architectural configurations of IEC 61499-based control applications. To define different configuration problems from real-world situations, I identify domain-specific constraints and objectives. Furthermore, I will tackle the problem of runtime reconfiguration by applying several optimization strategies in various context scenarios and investigating an incremental search for new optimal configurations.

Supporting changes in software models is becoming increasingly important. Some of these changes are induced by non-functional analysis that is usually conducted on different models and tools. Therefore, it becomes crucial to develop methods that allow automated transformations between these two families of models throughout the development cycle. To this extent, in the last decade, a number of approaches have been introduced to generate non-functional analysis models from software models. However, when analysis models are modified to meet non-functional requirements, changes are not propagated to update the software model. Automating the identification and propagation of changes would better support a round-trip analysis process. In this PhD program, we aim at introducing automation in the model-driven assessment of dependability, and we propose to leverage bidirectional model transformations to: (i) generate dependability analysis models from software models, and (ii) automatically propagate changes, driven by dependability requirements satisfaction, from analysis models back to software models. In particular, we intend to extend JTL, that is a bidirectional model transformations framework designed for model synchronization and change propagation, to handle problems that may arise from the application of bidirectional transformations in the context of dependability assessment.

Model-driven engineering (MDE) enables domain experts to specify, validate and maintain software systems without requiring advanced programming skills. An important challenge when treating models as primary artifacts in the software development process is maintaining consistency between them. Consistency management subsumes tasks such as consistency checking, model transformation and update propagation.

However, strict consistency is almost impossible to achieve in practical applications and is often not even a desirable goal. For instance, small updates in a source model can lead to substantial changes in the respective target model, making automated steps incomprehensible for the user and therefore decreasing the trustworthiness of the software system.

Ongoing research explores how to deal with inconsistency while still guaranteeing formal properties. However, conceptual and practical work on systems that tolerate inconsistencies to a certain extent is rather sparse. To the best of our knowledge, there is no MDE tool which supports all consistency management tasks mentioned before in a tolerant manner.

This short paper provides a roadmap for possible approaches to address the problem of handling inconsistencies with help of bidirectional transformation (bx) tools. The bx tool eMoflon will be taken as a concrete example to demonstrate the theoretical concepts. It uses Triple Graph Grammars (TGGs) as an underlying formalism to express the consistency relation between source and target models.