MODELSWARD 2019 Abstracts


Area 1 - Applications and Software Development

Full Papers
Paper Nr: 4
Title:

Realization of a Machine Learning Domain Specific Modeling Language: A Baseball Analytics Case Study

Authors:

Kaan Koseler, Kelsea McGraw and Matthew Stephan

Abstract: Accompanying the Big Data (BD) paradigm is a resurgence in machine learning (ML). Using ML techniques to work with BD is a complex task, requiring specialized knowledge of the problem space, domain specific concepts, and appropriate ML approaches. However, specialists who possess that knowledge and programming ability are difficult to find and expensive to train. Model-Driven Engineering (MDE) allows developers to implement quality software through modeling using high-level domain specific concepts. In this research, we attempt to fill the gap between MDE and the industrial need for development of ML software by demonstrating the plausibility of applying MDE to BD. Specifically, we apply MDE to the setting of the thriving industry of professional baseball analytics. Our case study involves developing an MDE solution for the binary classification problem of predicting if a baseball pitch will be a fastball. We employ and refine an existing, but untested, ML Domain-Specific Modeling Language (DSML); devise model instances representing prediction features; create a code generation scheme; and evaluate our solution. We show our MDE solution is comparable to the one developed through traditional programming, distribute all our artifacts for public use and extension, and discuss the impact of our work and lessons we learned.

Paper Nr: 16
Title:

TRILATERAL: Software Product Line based Multidomain IoT Artifact Generation for Industrial CPS

Authors:

Aitziber Iglesias, Markel Iglesias-Urkia, Beatriz López-Davalillo, Santiago Charramendieta and Aitor Urbieta

Abstract: Internet of Things (IoT) devices are usually advanced embedded systems that require functionalities monitoring and control. The design, development and validation of these devices is complex, even more when communication capabilities need to be included. In industrial environments, where safety is of critical importance, reducing this complexity can help to achieve the vision of Industry 4.0 by reducing development time and costs as well as increasing quality. To this end, the use of Model-Driven Engineering (MDE) methodology and the Software Product Line (SPL) paradigm is becoming increasingly important as they help to accelerate and ease the development of software, while reducing bugs and errors. Thus, in this work we present TRILATERAL, a SPL Model Based tool that uses a Domain Specific Language (DSL) to allow users to graphically define the IEC 61850 information model of the Industrial Cyber-Physical System (ICPS). TRILATERAL automatically generates the source code for communicating devices with the monitoring framework, also supporting a variety of communication protocols, namely HTTP-REST, WS-SOAP and CoAP in order to control/monitor any ICPS. In addition, the solution was evaluated deploying it in different industrial domains (Wind Farm, Smart Elevator, Catenary-free Tram) from which we gained important lessons.

Short Papers
Paper Nr: 44
Title:

Using Synchronizing Heuristics to Construct Homing Sequences

Authors:

Berk Çirişci, M. Y. Emek, Ege Sorguç, Kamer Kaya and Husnu Yenigun

Abstract: Computing a shortest synchronizing sequence of an automaton is an NP-Hard problem. There are well-known heuristics to find short synchronizing sequences. Finding a shortest homing sequence is also an NP-Hard problem. Unlike existing heuristics to find synchronizing sequences, homing heuristics are not widely studied. In this paper, we discover a relation between synchronizing and homing sequences by creating an automaton called homing automaton. By applying synchronizing heuristics on this automaton we get short homing sequences. Furthermore, we adapt some of the synchronizing heuristics to construct homing sequences.

Paper Nr: 49
Title:

Towards Model-driven Verification of Robot Control Code using Abstract Syntax Trees in Production Systems Engineering

Authors:

Kristof Meixner, Dietmar Winkler, Petr Novák and Stefan Biffl

Abstract: Context. In Production Systems, software components are often tightly connected to defined hardware device types like robots. Different types of robots, even from the same vendor, often use vendor-specific programming languages. Therefore, the exchange of devices or device types, e.g., during system evolution, is challenging and needs new or adapted control software and repeated verification and validation process steps, even if the software behavior remains unchanged. Models aim at supporting these verification and validation tasks during system evolution. Objective. This position paper aims at providing a verification and validation process approach with models for supporting automation systems maintenance and evolution processes. For evaluation purposes, we report on a feasibility study with a focus on two selected robot types in the context of Production Systems Engineering (PSE). Method. We use the Abstract Syntax Tree (AST) concept as a foundation for generating models as the basis for human-based verification and validation. Based on two generated AST variants, related to old and new software control code, human experts can compare the behavior of the expected system to verify and validate the code. Results. First results showed the feasibility of the AST concept to support human-based verification and validation in the context of PSE maintenance projects on a structural level. Conclusion. Although the human-based verification and validation process is feasible and promising on a structural level, the complexity of AST for large-scale models needs to be addressed by tool support to overcome complexity levels of the production system and limitations of human-based verification and validation.

Paper Nr: 59
Title:

Towards Privacy-aware Software Reuse

Authors:

Iris Reinhartz-Berger, Anna Zamansky and Agnes Koschmider

Abstract: As software becomes more complex, reusing and integrating artifacts from existing projects that may be taken from open or organization-proprietary repositories is becoming an increasingly important practice. This practice requires an in-depth understanding of the projects to be reused and particularly their common and variable features and their non-functional requirements. Different approaches have been suggested to analyze similarity and variability of different kinds of artifacts (mainly, requirements and code), e.g., clone detection and feature mining. These approaches, however, mainly address functional aspects of the software artifacts, while mostly neglecting aspects dictated by non-functional requirements. The recent progress with the General Data Protection Regulation (GDPR) highlights the importance of handling privacy concerns in software development. However, existing approaches do not directly refer to privacy challenges in software reuse. In this paper we propose integrating these two lines of research and introduce a privacy-aware software reuse approach. Particularly, we suggest to extend VarMeR – Variability Mechanisms Recommender – which analyzes software similarity based on exhibited behaviors and recommends on polymorphism-inspired reuse mechanisms, with privacy awareness considerations. These considerations are reflected in “privacy levels” of the reused artifacts.

Paper Nr: 72
Title:

Something is Rotten in the State of Documenting Simulink Models

Authors:

Vera Pantelic, Alexander Schaap, Alan Wassyng, Victor Bandur and Mark Lawford

Abstract: In this paper we draw on our experience in the automotive industry to portray the clear need for proper documentation of Simulink models when they describe the implementations of embedded systems. We effectively discredit the “model is documentation” motto that has been hounding the model-based paradigm of software development. The state of the art of documentation of Simulink designs of embedded systems, both in academia and industrial practice, is reviewed. We posit that lack of proper documentation is costing industry dearly, and propose that a significant change in development culture is needed to properly position documentation within the software development process. Further, we discuss what is required to foster such a culture.

Paper Nr: 6
Title:

Software Product Line Engineering for Safety-critical Systems

Authors:

Philipp Lohmüller and Bernhard Bauer

Abstract: Nowadays, modern cars can be configured by means of a wide range of software configuration options. In this context, we speak about Software Product Lines (SPLs). In almost every modern automotive vehicle safety-critical components like, e.g., an Adaptive Cruise Control (ACC) are installed. Some SPLs have different safety-critical requirements whereas other SPLs have similar requirements. This paper proposes an approach for the reduction of the complexity of SPLs without loss of safety (aspects) for all participants. For this purpose, a concept has been developed, which clusters products of SPLs with similar safety-critical requirements, i.e., the set of products of an SPLs, which must still be tested, can be reduced immensely. The paper also provides an application example how the reduced set can be used in order to perform a Safety, Security and Timing (SST) based trade-off analysis.

Paper Nr: 55
Title:

Quantity Checking through Unit of Measurement Libraries, Current Status and Future Directions

Authors:

Steve McKeever, Görkem Paçaci and Oscar Bennich-Björkman

Abstract: Unit errors are known to have caused some costly software engineering disasters, most notably the Mars Climate Orbiter back in 1999. As unit annotations are not mandatory for execution only dramatic events become newsworthy. Anecdotally however, there is evidence to suggest that these kinds of errors are recurrent and under-reported. There are an abundance of tools and most notably libraries to aid scientific developers manage unit definitions. In this paper we look in detail at how a number of prominent libraries in the most popular programming languages support units. We argue that even when these libraries are based on a sound design pattern, their implementation becomes too broad. Each library is distinct with varying features, lacking a core API, compromising both interoperability and thereby usage. We claim that further library or tool development is not needed to further adoption, but that a greater understanding of developers requirements is.

Paper Nr: 64
Title:

An Approach for Workflow Improvement based on Outcome and Time Remaining Prediction

Authors:

Luis Galdo Seara and Renata Medeiros de Carvalho

Abstract: Some business processes are critical to organizations. The efficiency at which involved tasks are performed define the quality of the organization. Detecting where bottlenecks occur during the process and predicting when to dedicate more resources to a specific case can help to distribute the work load in a better way. In this paper we propose an approach to analyze a business process, predict the outcome of new cases and the time for its completion. The approach is based on a transition system. Two models are then developed for each state of the transition system, one to predict the outcome and another to predict the time remaining until completion. We experimented with a real life dataset from a financial department to demonstrate our approach.

Paper Nr: 79
Title:

Model Assurance Levels (MALs) for Managing Model-based Engineering (MBE) Development Efforts

Authors:

Julie S. Fant and Robert G. Pettit

Abstract: Model-based engineering (MBE) in industry is on the rise. However, improvements are still needed on the oversight and management of MBE efforts. Frequently, program managers and high-level decision makers do not have background in MBE to understand models, the value the models are providing, and if they are successfully achieving their MBE goals. To address these concerns, we developed a rating scale for models, called Model Assurance Levels (MALs). The purpose of the MALs is to be able to quickly and concisely express the assurance the model is providing to the program, as well as, risks associated with the model. Therefore, given a MAL level, program managers and decision makers will be able to quickly understand the model value and risks associated with the model. They can then make informed decisions about the future direction of MBE development effort.

Area 2 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 36
Title:

Single Underlying Models for Projectional, Multi-View Environments

Authors:

Johannes Meier, Heiko Klare, Christian Tunjic, Colin Atkinson, Erik Burger, Ralf Reussner and Andreas Winter

Abstract: Multi-view environments provide different views of software systems optimized for different stakeholders. One way of ensuring consistency of overlapping and inter-dependent information contained in such views is to project them “on demand” from a Single Underlying Model (SUM). However, there are various ways of building and evolving such SUMs. This paper presents criteria to distinguish them, describes three archetypical approaches for building SUMs, and analyzes their advantages and disadvantages. From these criteria, guidelines for choosing which approach to use in specific application areas are derived.

Short Papers
Paper Nr: 25
Title:

DFEAM: Dynamic Feature-oriented Energy-aware Adaptive Modeling

Authors:

Fumiya Tanaka, Kenji Hisazumi and Akira Fukuda

Abstract: There is an increasing demand for reducing the power consumption in the field of embedded-system development. A development methodology, which can change software’s power consumption according to the power consumption of the hardware, can help fulfill this requirement. However, there will be a trade-off between the power consumption and service quality, which must be balanced for efficient operation. In this paper, we propose dynamic feature-oriented energy-aware adaptive modeling (DFEAM), which develops self-adaptive software through model-driven development for achieving a proper balance between the power consumption and quality of service (QoS). In this method, the application itself decides its behavior, according to the power-consumption situation, by linking the feature model describing the variability of the application with the description of its behavior, using the executable and translatable unified modeling language (xtUML). For achieving a satisfactory QoS for variations that are complex and dependent on variable points, a model is created to quantify the QoS values, which is then used as an index of comparison for finding the optimum variation. We conducted case studies on applications with multiple variable points, and evaluated them using the GQM model. The results of the evaluation showed that the adaptation incorporated provided the maximum software quality under the given power limitations, thus verifying the usefulness of the proposed DFEAM method.

Paper Nr: 45
Title:

An Approach to Design Smart Grids and Their IT System by Cosimulation

Authors:

David Oudart, Jérôme Cantenot, Frédéric Boulanger and Sophie Chabridon

Abstract: 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 electronics, software information processing and telecommunications technical domains. Therefore the design of smart grids is complex because of the various technical domains and modeling tools at stake. In this article, we present an approach to their design, which relies on model driven engineering, executable models and FMI based cosimulation. This approach is illustrated on the use case of an insular power grid and allows to study the impact of power production decisions.

Paper Nr: 47
Title:

Evaluating OpenCL as a Standard Hardware Abstraction for a Model-based Synthesis Framework: A Case Study

Authors:

Omair Rafique and Klaus Schneider

Abstract: In general, model-based design flows start from hardware-agnostic models and finally generate code based on the used model of computation (MoC). The generated code is then manually mapped with an additional non-trivial deployment step onto the chosen target architecture. This additional manual step can break all correctness-by-construction guarantees of the used model-based design, in particular, if the chosen architecture employs a different MoC than the one used in the model. To automatically bridge this gap, we envisage a holistic model-based design framework for heterogeneous synthesis that allows the modeling of a system using a combination of different MoCs. Second, it integrates the standard hardware abstractions using the Open Computing Language (OpenCL) to promote the use of vendor-neutral heterogeneous architectures. Altogether, we envision an automatic synthesis that maps models using a combination of different MoCs on heterogeneous hardware architectures. This paper evaluates the feasibility of incorporating OpenCL as a standard hardware abstraction for such a framework. The evaluation is presented as a case study to map a synchronous application on different target architectures using the OpenCL specification.

Paper Nr: 50
Title:

A Practical Medical Experience of Successfully Mixing Model-Driven Paradigm and Business Process Management Principles

Authors:

V. Cid-de-La-Paz, L. Morales and J. M. Ramos

Abstract: The Model-Driven Paradigm has been successfully used in several different software contexts and there are a lot of literature offering approaches, techniques and tools to guarantee its application in different areas, such as software design, software testing, and so on. But, this paradigm can be also used in other contexts offering very good results. In this paper, we illustrate the power of using models and transformations to make an effective and efficient management of clinical guides in medical environments. The paper shows how using business process management to represent clinical guidelines, principles of Model-Driven paradigm can be successfully used. The paper presents the experiences in the IDE4ICDS, which is framed into the medical context to provide a solution to manage the life cycle of clinical guidelines. This project presents a methodology that allows the management of clinical guidelines to be automated, as well as a software platform to support it. This platform has been validated with health professionals from the Hospital Virgen del Rocio (Seville), obtaining promising results. Nowadays, this platform is been validated by healthcare professionals of Primary Care with patients suffering from Diabetes Mellitus Type 2.

Paper Nr: 9
Title:

Emerging Concepts and Trends in Collaborative Modeling: A Survey

Authors:

Matthew Stephan

Abstract: Just as in other engineering disciplines, software engineering is well suited to collaboration; Having different perspectives and diverse experiences strengthens engineering projects. Software modeling is a fundamental aspect of software engineering and is becoming increasingly collaborative. Collaborative modeling approaches are maturing and related research is growing significantly. While surveys exist on collaborative modeling tools and research, they are aimed at academics and can be verbose. In this article, we conduct a research survey intended to provide practitioners and researchers an accessible and abstract at-a-glance perspective of emerging trends and directions in collaborative modeling. We complete a systematic literature review, which we crosscheck with existing surveys. To explicate trends in the last five complete years and overall trends, we perform concept extraction and domain analysis by analyzing abstracts. We visualize these trends in word clouds and trend charts, and provide insights. We hope this article helps spread awareness of collaborative modeling trends and future directions, and educates practitioners and researchers.

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 10
Title:

Unifying Modeling and Programming with Valkyrie

Authors:

Johannes Schröpfer and Thomas Buchmann

Abstract: Raising the level of abstraction when developing a software system is the driving force behind Model-driven software development (MDSD) – a software engineering paradigm which gained more and more attention during the last decade. The current state of the art in MDSD allows software engineers to capture the static structure in a model, e.g., by using class diagrams provided by the Unified Modeling Language (UML), and to generate source code from it. Furthermore, when it comes to expressing the behavior, i.e., method bodies, the UML offers a set of diagrams which may be used for this purpose. Unfortunately, not all UML diagrams come with a precisely defined execution semantics and thus, code generation is hindered. Recently, the OMG issued the standard for an Action Language for Foundational UML (ALF) which allows for textual modeling of software system and which provides a precise execution semantics. In this paper, a tight integration between our UML-based CASE tool and our ALF tool is presented. The resulting tool chain allows to express structure and behavior of a software system on the model level and to generate fully executable Java source code.

Paper Nr: 11
Title:

Meta-models Combination for Reusing Verification Techniques

Authors:

Hui Zhao, Ludovic Apvrille and Frédéric Mallet

Abstract: The complexity of Cyber-Physical Systems (CPSs) is rapidly increasing because more and more aspects have been considered during the design phase. Each aspect involves its domain-specific modeling language (DSML), How to combine various DSMLs was a challenging problem. Rather than build-in all analysis and modeling capacities, we prefer with independent domain specific metamodels and link them together. In this paper, we show how to use a coordinated metamodel approach as a systematic way to gather diverse domain models and cross-cutting concerns. Thus, the paper proposes a set of transformation operators to manipulate (AADL and SysML) metamodels. We show that we can thus enrich platform capacities by blending different languages seamlessly, as well as perform the functional and scheduling analysis respectively through concrete models. A train traction controlling system serves as a case study.

Paper Nr: 15
Title:

Resolving the Asymmetry of On-Exit versus On-Entry in Executable Models of Behaviour

Authors:

Vladimir Estivill-Castro and René Hexel

Abstract: For the UML, state charts are by far the most used modelling tools, both to communicate behaviour and to produce executable models. We investigate the inherent asymmetry of On-Entry and On-Exit Actions in UML Statecharts. We show first that the apparently simple and symmetric rules for handling the sequencing of On-Entry and On-Exit actions are hard to fully comprehend and apply effectively by software developers. Second, defining a semantics that results in executable models for applications such as reactive-systems and real-time systems is very delicate. Third, formal verification can be hampered because the semantics results in a combinatorial explosion of states. We evaluate the understandability of the semantics by taking out experiments with various tasks comprising sample UML Statechart and logic-labelled finite state machines (LLFSMs). Several experiments with software developers enable us to dissect how issues of understandability of state diagrams relate to nesting or event-driven vs logic-labelled. Since logic-labelled finite state machines achieve model composition through a subsumption architecture (suspend/restart/resume) we propose a specific alternative semantics for logic-labelled finite state machines that is suitable for robotic and embedded systems.

Paper Nr: 23
Title:

Model Federation based on Role Modeling

Authors:

Bastien Drouot and Joël Champeau

Abstract: Modeling approaches could be a powerful solution for specification, design and analysis. At a system level, models must take into account many system concerns. Thus, several system modeling approaches are based on several viewpoints expressed in Domain Specific Modeling Languages. Cyber threat analysis takes place within this modeling context with the need for several DSMLs to address several viewpoints of the system. So, the analysis of this domain is supported by DSML interoperability to perform simulation or other algorithms. Therefore, in this paper, we present an approach to face DSML interoperability based on role modeling. The Role4All framework is based on a metamodel including the Role concept. The Role4All language provides the capacity to define shared semantics between the DSMLs. Role4All and role modeling avoid model transformations and promote a federation approach between several DSMLs. The federation mechanisms of Role4All are illustrated in the cyber threat modeling framework to emphasize information gathering and the updates of the role model.

Paper Nr: 28
Title:

Efficient Data-Flow Analysis of UML/SysML Diagrams for Optimized Model Compilation of Hardware-software Systems

Authors:

Andrea Enrici, Ludovic Apvrille and Renaud Pacalet

Abstract: Growing needs in terms of latency, throughput and flexibility are driving the architectures of tomorrow’s Radio Access Networks towards more centralized configurations that rely on cloud-computing paradigms. In these new architectures, digital signals are processed on a large variety of hardware units (e.g., CPUs, Field Programmable Gate Arrays, Graphical Processing Units). Optimizing model compilers that target these architectures must rely on efficient analysis techniques to optimally generate software for signal-processing applications. In this paper, we present a blocking combination of the iterative and worklist algorithms to perform static data-flow analysis on functional views denoted with UML Activity and SysML Block diagrams. We demonstrate the effectiveness of the blocking mechanism with reaching definition analysis of UML/SysML models for a 5G channel decoder (receiver side) and a Software Defined Radio system. We show that significant reductions in the number of unnecessary visits of the models’ control-flow graphs are achieved, with respect to a non-blocking combination of the iterative and worklist algorithms.

Paper Nr: 31
Title:

Umple as a Template Language (Umple-TL)

Authors:

Mahmoud H. Orabi, Ahmed H. Orabi and Timothy C. Lethbridge

Abstract: We extend Umple, a model-oriented programming language, to incorporate text emission from templates as an integral feature. Umple as a template language (Umple-TL) is the term we use to describe the template sublanguage of Umple. Using Umple-TL, developers can benefit from synergies among UML modelling, templating and programming in several target languages (Java, C++), all in one textual language – Umple. Umple itself is written in Umple; using Umple-TL, we eliminated Umple's dependency on third-party libraries for text emission. We also support any other application developed in JET to be converted to use Umple-TL and attain benefits such as smaller and faster executables, target-language independence and IDE independence. The word ‘template’ in this paper refers to patterns for the generation of output, and not to generic types, another common use of the term.

Paper Nr: 34
Title:

Model Driven Data Management in Healthcare

Authors:

David Milward

Abstract: Healthcare research depends on the availability of data that is of high quality, that is easy to query, consistent and current. Traditionally, healthcare data has relied on multiple diverse datasets being integrated by domain experts. These integration processes are executed with a high degree of human involvement, integrating datasets can be time-consuming and can result in the introduction of errors into the data. This paper describes work to build an integration toolset for healthcare datasets based on the ISO11179 Standard for metadata registries. It describes issues encountered whilst implementing the standard and shows how these short-comings were overcome by using techniques from the field of Model Driven Engineering (MDE).

Paper Nr: 56
Title:

Decoupling Language and Editor - The Impact of the Language Server Protocol on Textual Domain-Specific Languages

Authors:

Hendrik Bünder

Abstract: Model-Driven Software Development using Domain-Specific Languages (DSL) has been widely adopted throughout research and industry. The language workbenches required to efficiently build Domain-Specific Languages and the associated editor support are often deeply integrated into a specific Integrated Development Environment (IDE). Thereby, the chosen Domain-Specific Language workbench predicts the IDE required to use the DSL. Yet, this IDE might not be the best choice for further implementing, testing, and debugging the generated code. A case study was conducted to analyze how the Language Server Protocol could be utilized to decouple the DSL implementation from a specific editor integrated into an IDE. First, the Language Server Protocol capabilities are exemplified by building editor support for an Entity-DSL that is integrated into two different IDEs. Second, a SWOT analysis is carried out to identify strengths and weaknesses as well as opportunities and threats for Domain-Specific Languages utilizing the Language Server Protocol. The case study’s results indicate that the Language Server Protocol enables efficient multi-editor integration. Further, the results of the SWOT analysis imply potential benefits for cross-functional teams specifying a shared domain model.

Paper Nr: 62
Title:

On-the-Fly Construction of Composite Events in Scenario-Based Modeling using Constraint Solvers

Authors:

Guy Katz, Assaf Marron, Aviran Sadon and Gera Weiss

Abstract: Scenario-Based Programming is a methodology for modeling and constructing complex reactive systems from simple, stand-alone building blocks, called scenarios. These scenarios are designed to model different traits of the system, and can be interwoven together and executed to produce cohesive system behavior. Existing execution frameworks for scenario-based programs allow scenarios to specify their view of what the system must, may, or must not do only through very strict interfaces. This limits the methodology’s expressive power and often prevents users from modeling certain complex requirements. Here, we propose to extend Scenario-Based Programming’s execution mechanism to allow scenarios to specify how the system should behave using rich logical constraints. We then leverage modern constraint solvers (such as SAT or SMT solvers) to resolve these constraints at every step of running the system, towards yielding the desired overall system behavior. We provide an implementation of our approach and demonstrate its applicability to various systems that could not be easily modeled in an executable manner by existing Scenario-Based approaches.

Paper Nr: 71
Title:

Generic Framework for Evaluating Commutativity of Multi-Variant Model Transformations

Authors:

Sandra Greiner and Bernhard Westfechtel

Abstract: Multi-variant model transformations (MVMTs) aim at automatically propagating variability annotations present in software product lines (SPL) when executing state-of-the-art model transformations. Variability annotations are boolean expressions used in annotative SPL engineering (SPLE) for expressing in which products model elements are visible. Developing the SPL in a model-driven way requires various model representations, e.g., database schemata for data storage or Java models for the code generation. Although model transformations are the key essence of model-driven software engineering (MDSE) and can be used to generate these representations from already existing (model) artifacts, they suffer from not being able to handle the variability annotations. Thus, the developer is forced to annotate target models manually contradicting the goal of both disciplines, MDSE and SPLE, to increase productivity. Recently, approaches have been proposed to solve the problem using, e.g., traces, to propagate annotations without changing the transformation itself. For evaluating the outcome all of the approaches require the transformation to commute w.r.t. the derived products. Although the criterion is the same, a common framework for testing it does not exist. Therefore, we contribute a generic framework allowing to evaluate whether the target model of arbitrary (reuse-based) MVMTs was correctly annotated according to the shared commutativity criterion.

Paper Nr: 76
Title:

Extending EAST-ADL for Modeling and Analysis of Partitions on Functional Architectures

Authors:

Christoph Etzel and Bernhard Bauer

Abstract: The complexity in automotive systems engineering is increasing over the last decade. In particular, new comfort functions as well as functions towards autonomous driving are reasons for this complexity. A new dimension is introduced by the usage of multi-core processors since there is a shift from sequential to parallel thinking in the different development phases. Therefore, in this paper we present an approach for supporting the development process of distributed systems aligned with the EAST-ADL approach, by using partitioning. We present an extension to EAST-ADL for partitioning and show ways how an automatic partitioning on different levels of abstraction can be achieved. These partitions can support system designers during the design process of functional architectures, by giving a first insight how well the functional components can be distributed on hardware in later stages of the development process.

Paper Nr: 78
Title:

A Flexible Framework for Program Evolution and Verification

Authors:

Olaf Owe, Jia-Chun Lin and Elahe Fazeldehkordi

Abstract: We propose a flexible framework for modeling of distributed systems, supporting evolution by means of unrestricted modifications in such systems, and with support of verification and re-verification. We focus on the setting of concurrent and object-oriented programs, and consider a core high-level modeling language supporting active, concurrent objects. We show that our framework can deal with verification of software changes that are not possible to verify in comparable frameworks. We demonstrate the approach by variations over a simple example.

Short Papers
Paper Nr: 7
Title:

Applying Metamodel-based Tooling to Object-oriented Code

Authors:

Heiko Klare, Timur Saglam, Erik Burger and Ralf Reussner

Abstract: Model-driven development processes mainly from the capabilities of modelling frameworks, since these offer an explicit representation of model elements and features, as well as reusable tooling, such as transformation languages or editor frameworks. Nevertheless, most software systems are not developed in a model-driven way although they do contain implicit models encoded in their object-oriented design. Adaptation to model-driven tooling imposes high manual effort and easily breaks compatibility with dependent code and existing tooling. We present an automated and minimally intrusive approach that makes implicit models in software systems explicit. We adapt existing object-oriented code so that it provides an explicit model representation, while preserving its original API. As a result, capabilities of modelling frameworks, such as persistence and change notifications, can be integrated into object-oriented code, and enable the application of reusable tools. We provide a classification of requirements that existing code has to fulfill, usable as an indicator for the applicability of modelling tools to them. An evaluation based on one artificial and two open-source case study systems shows the correct preservation of the API, as well as the ability to apply tooling to the modified code.

Paper Nr: 14
Title:

Case Studies in Model-Driven Reverse Engineering

Authors:

André Pascal

Abstract: Without abstraction, third party maintenance can hardly make evolve (even documented) software applications. In this paper we address the problem of re-engineering software applications to add abstraction in order to improve their continuous evolution. In three different case studies, we make use of Model-Driven Reverse Engineering for extracting component software architecture, for aligning business and application logic in information systems and for re-engineering a holonic software manufacturing process. We report lessons learnt for future developments.

Paper Nr: 19
Title:

Semantic Differencing of Statecharts for Object-oriented Systems

Authors:

Imke Drave, Robert Eikermann, Oliver Kautz and Bernhard Rumpe

Abstract: Statecharts are well-suited to describe the behavior of objects in object-oriented systems. Effective statechart evolution analysis for detecting errors and exploring design alternatives requires to reveal the semantic differences from one statechart to another. Previous work has not produced approaches to semantic differencing of statecharts for object-oriented systems. This paper defines a syntax and a semantics for reduced UML/P statecharts and presents an explicit semantics-preserving translation from statecharts to finite automata. This enables to reduce semantic statechart differencing to language inclusion checking between finite automata. The translation is formally defined and proven to be correct. This paper further introduces operators for hiding and matching events to compare statecharts semantically on different levels of abstraction. The result is a sound and complete method for semantic differencing of statecharts and abstraction methods, which ultimately facilitates semantic statechart evolution analysis.

Paper Nr: 32
Title:

Design Guidelines for Feature Model Construction: Exploring the Relationship between Feature Model Structure and Structural Complexity

Authors:

Xin Zhao and Jeff Gray

Abstract: Software Product Lines (SPLs) play an important role in the context of large-scale production of software families. Feature models (FMs) are essential in SPLs by representing all the commonalities and variabilities in a product line. Currently, several tools support automated analysis of FMs, such as checking the consistency of FMs and counting the valid configurations of a product line. Although these tools greatly reduce the complexity of FM analysis, FM design is often performed manually, thus being prone to bad design choices in the domain analysis phase. This paper reports on our work to improve FM qualities from the exploration of the relationship between FM structure and structural complexity. By performing two common operations (i.e., consistency checking and counting valid configurations on FMs with different sizes and structures), we collected the time that an automated tool needs to finish these operations. Then, we applied data mining approaches to explore the relationship between FM structure and structural complexity. In addition, we provide guidelines for designing FMs based on our observations.

Paper Nr: 38
Title:

A Language-oriented Approach for the Maintenance of Megamodel-based Complex Systems

Authors:

El B. Toure, Ibrahima Fall, Alassane Bah, Mamadou S. Camara, Mandicou Ba and Ahmad Fall

Abstract: Model Driven Engineering (MDE) provides the concept of a runtime megamodel to represent the dynamic structure of a given system, to which it is causally connected. A system changes at runtime therefore implies frequent and dynamic changes of its related megamodel. In a previous work we have proposed to automate change management through a runtime megamodel evolution management approach. In such an approach, a megamodel manipulation, a kind of programming in-the-large activity, is considered as a mega-program which is modified throughout Global Operation Models (GOMs). Then we proposed a safe execution of GOMs as the solution for megamodel consistency preserving during evolution. In this work, we propose LAMEME, a domain-specific language for the management and the evolution of megamodels, and its axiomatic semantics. LAMEME gives the possibility to express an evolving megamodel as a mega-program and therefore defines a framework that supports our previously proposed approach.

Paper Nr: 39
Title:

How to Bootstrap a Language Workbench

Authors:

Andreas Prinz and Alexander Shatalin

Abstract: Language workbenches are designed to enable the definition of languages using appropriate meta-languages. This makes it feasible to define the environments by themselves, as the meta-languages are also just languages. This approach of defining an environment using itself is called bootstrapping. Often, such bootstrapping is difficult to achieve and has to be built deeply into the environment. The platform Meta-Programming System (MPS) has used bootstrapping for its own definition. In a similar way, the environment LanguageLab is using bootstrapping for its definition. This paper reports the implementation of LanguageLab in MPS thereby also porting the bootstrapping. From the experiences general requirements for bootstrapping language workbenches are derived.

Paper Nr: 46
Title:

Bridging XML and UML - An Automated Framework

Authors:

Arthur Kühlwein, Sebastian Reiter, Wolfgang Rosenstiel and Oliver Bringmann

Abstract: A large variety of data is serialized and exchanged using XML. Model-driven activities can benefit from XML data, as shown by various approaches to IP-XACT and UML integration. However, these approaches are inherently time consuming, error-prone, and inflexible due to the manual effort involved. We propose an automated framework for integrating arbitrary XML data into UML models using an automatically generated UML profile corresponding to the structure of the XML data. User-defined XML-to-UML mappings further enhance this integration. Our approach mitigates the aforementioned issues while providing the same benefits.

Paper Nr: 53
Title:

Dataflow-based Heterogeneous Code Generator for IoT Applications

Authors:

Gábor Paller, Endri Bezati, Nebojša Taušan, Gábor Farkas and Gábor Élő

Abstract: The latest wave of connected digital systems, nowadays called Internet of Things (IoT) promises various gains, especially in terms of significant ease of data access. A large number of different platforms for IoT applications, however, makes their development difficult and time-consuming leading to projects that are failed to be on time, on budget or fully completed. To address the platform heterogeneity, this paper presents the ongoing work on development environment called Orcc-IoT. Orcc-IoT facilitates the development of IoT by combining dataflow modelling language, heterogeneous code generator and the library of ready-made IoT actors. The utilisation of Orcc-IoT in development is expected to increase the quality, and to reduce the development costs and time-to-market of IoT applications.

Paper Nr: 54
Title:

A Tool for High-level Modeling of Analog/Mixed Signal Embedded Systems

Authors:

Daniela Genius, Rodrigo C. Porto, Ludovic Apvrille and François Pêcheux

Abstract: Embedded systems are commonly built upon heterogeneous digital and analog integrated circuits, including sensors and actuators. Model-driven approaches for designing software and hardware have been proposed, yet they are generally limited to the digital parts of systems. This paper presents the extension of an integrated modeling and simulation tool for the verification and virtual prototyping of embedded systems described at different abstraction levels to analog/mixed-signal systems.

Paper Nr: 61
Title:

Using Reactive-System Modeling Techniques to Create Executable Models of Biochemical Pathways

Authors:

Hadas Lapid, Assaf Marron, Smadar Szekely and David Harel

Abstract: Scenario-based modeling (SBM) is an emerging approach for creating executable models of complex reactive systems. In addition to its use in software and system development, SBM has been shown to serve well in modeling biological processes. In this position paper, we show that SBM can be used effectively in modeling biochemical pathways at the molecular level, complementing existing biochemical modeling techniques. One of the key benefits of these SBM models is in helping professionals and students better conceptualize and understand such complex processes.

Paper Nr: 63
Title:

Business Process Modeling Flexibility: A Formal Interpretation

Authors:

Anila Mjeda, Andrew Butterfield and John Noll

Abstract: Domain experts from both the software and business process modelling domains concur on the importance of having concurring and co-supportive business and software development processes. This is especially important for organisations that develop software for regulated domains where the software development processes need to abide by the requirements of the domain-specific quality assurance standards. In practice, even when following quite mature development processes to develop high assurance systems, software development is a complex activity that typically involves frequent deviations and requires considerable context-sensitive flexibility. We took a business process modelling notation called PML that was specifically designed to be lightweight and allow flexibility, and developed formal semantics for it. PML supports a range of context-sensitive interpretations, from an open-to-interpretation guide for intended behaviour, to requiring a precise order in which tasks must occur. We are using Unifying Theories of Programming (UTP) to model this range of semantic interpretations and the paper presents a high-level view of our formal semantics for PML. We provide examples that illustrate the need for flexibility and how formal semantics can be used to analyse the equivalence of, or refinement between, strict, flexible, and weak semantics. The formal semantics are intended as the basis for tool support for process analysis and have applications in organisations that operate in regulated domains, covering such areas as the certification process for medical device software.

Paper Nr: 67
Title:

Towards Mainstream Multi-level Meta-modeling

Authors:

Gergely Mezei, Ferenc A. Somogyi, Zoltán Theisz, Dániel Urbán and Sándor Bácsi

Abstract: In recent years, a wide range of tools and methodologies have been introduced in the field of multi-level meta-modeling. One of the newest approaches is the Dynamic Multi-Layer Algebra (DMLA). DMLA incorporates a fully self-modeled textual operation language (DMLAScript) over its tuple-based model entity representation. This textual language provides effective and complex features when editing models. On the other hand, the language supports the precise injective mapping of the multi-layers. However, such complexity comes at a price. Using DMLAScript can be difficult in practice for users who are only familiar with the classical, object-oriented way of thinking, and are not confident with the multi-level approach. In this paper, we introduce the concepts of a new language above DMLAScript, which supports the more effective manipulation of concrete domain models by taking advantage of the particular process of multi-level modeling within DMLA. Although the approach is technically bound to DMLA, the concepts discussed in the paper are of general use.

Paper Nr: 69
Title:

IFVM Bridge: A Virtual Machine for IFML Models Execution in Combination with Domain Models

Authors:

Sara Gotti and Samir Mbarki

Abstract: Many software systems are executable on various computing devices. No one denies that each of these devices has its own user interfaces. Nevertheless, this trend of computing everywhere is not accompanied by a solution that can be used to abstractly express the content, user interaction and control behavior of the software application front end without focusing on the implementation platform. Applying the concept of abstract models to user interfaces become a necessity. Accordingly, OMG adopted (in March 2013) the new Interaction Flow Modeling Language (IFML) for abstractly describing the system front end. It ensures executability in order to be mapped into executable applications for different kind of devices. In this paper, we propose a new model driven development approach to execute the logical description of UIs components and their interactions captured with IFML. We define IFVM, a virtual machine for executing IFML models with focus on the content-dependent navigation specification for passing parameters between the ViewElements, and the Data binding specification to specify the source of the published content.

Paper Nr: 70
Title:

Application Configuration via UML Instance Specifications

Authors:

Ansgar Radermacher, Shuai Li and Matteo Morelli

Abstract: One way to design complex systems is to use a model driven approach. Model Driven Engineering (MDE) promotes the use of models are primary artifact for analysis, design and implementation of a system. In this paper, we focus on component-based models including classes (representing components), hierarchical composition (classes with parts) and instance specifications. Instance specifications describe instances of a system, i.e. provide values for (a subset of) the attributes of class attributes. However, the use of instance specifications without additional tool support is tedious, since several references need to be setup. This paper will show some mechanisms (notably tables) to ease the usability. There are also different ways to organise instance specifications which have advantages and inconveniences. This paper lists them and provide hints in which situation a certain variant could be used. Code generation from models needs to take instance configuration into account, but application configuration via instances is still not fully supported by all tools. We will show how code generated from instance specifications can look like. This code becomes more interesting for adaptive applications that need to change between different configurations at runtime.

Paper Nr: 74
Title:

Modelling the Behaviour of Context-aware Systems: State-of-the-Art Analysis and Introduction of a Customized UML Profile

Authors:

Patrick Rosenberger, Detlef Gerhard and Stefan Dumss

Abstract: The usage of smart devices in combination with the extensive deployment of sensors enables the development of systems that can recognize their environment and act accordingly. These so-called context-aware systems allow the automation of the user interactions by providing the desired functionality based on an understanding of the users' current context. During the development of such systems, the context-related system properties, the contextual functionalities, as well as the underlying contexts must be defined. UML models are a valuable tool for such tasks. In this publication, the previous research regarding the graphical representation of context-aware systems is analysed. It is shown that the modelling of contextual behaviour is still not addressed sufficiently. To counter this issue, contextual design templates are introduced. These templates allow the visualization of different system properties by combining the UML standard notation with a newly introduced notation for stating contexts. Further, a profile for the modelling of contexts and related system functionalities is presented.

Paper Nr: 75
Title:

Towards Goal-oriented Analysis and Redesign of BPMN Models

Authors:

Christophe Ponsard and Robert Darimont

Abstract: The Business Process Management lifecycle involves identifying, analysing and evolving the design of an organisation’s tasks. Modelling plays a key role in those activities to capture the processes but also the related goals representing the rationale behind them. While some mappings have been defined between such models, they lack guidelines to support analysis or (re)design activities in order to improve processes in an evolving organisation. The purpose of this paper is to propose a two-staged guidance: (1) a lightweight approach leaving the goal model implicit but using goal reasoning techniques; and (2) an heavier approach where an explicit goal model is explicitly built and mapped to support the redesign process. Our work is experimented on a running case study inspired from a logistics system. Although still in progress, we were able to uncover interesting problems and to suggest relevant redesigns.

Paper Nr: 77
Title:

Modular Construction of Context-Specific Test Case Migration Methods

Authors:

Ivan Jovanovikj, Enes Yigitbas, Marvin Grieger, Stefan Sauer and Gregor Engels

Abstract: Migration of test cases has a twofold benefit in software migration projects: reuse of valuable knowledge as well as time and cost savings. The diversity of software migration project contexts require a flexible and modular construction method to address several aspects like different system and test environments or the impact of the system changes on the test cases. When an inappropriate migration method is used, it may increase the effort and the costs and also decrease the overall software quality. Therefore, a critical task in test case migration is to provide a transformation method which fits the context. To address this problem, in this paper, we present a framework that enables a modular construction of context-specific migration methods for test cases by assembling predefined building blocks. Our approach builds upon an existing framework for modular construction of software transformation methods and consists of a method base and a method engineering process. Method fragments are the atomic building blocks of a migration method, whereas method patterns encode specific migration strategies. The guidance on development and enactment of migration methods is provided by the method engineering process. We evaluate our approach in an industrial case study where a part of the Eclipse Modeling Framework was migrated from Java to C#.

Paper Nr: 2
Title:

Executable State Machines Derived from Structured Textual Requirements - Connecting Requirements and Formal System Design

Authors:

Benedikt Walter, Jan Martin, Jonathan Schmidt, Hanna Dettki and Stephan Rudolph

Abstract: There exists a gap between (textual) requirements specification and systems created in the system design process. System design, particular in automotive, is a tremendously complex process. The sheer number of requirements for a system is too high to be considered at once. In industrial contexts, complex systems are commonly created through many design iterations with numerous hardware samples and software versions build. System experts include many experience-based design decisions in the process. This approach eventually leads to a somewhat consistent system without formal consideration of requirements or a traceable design decision process. The process leaves a de facto gap between specification and system design. Ideally, requirements constrain the initial solution space and system design can choose between the design variants consistent with that reduced solution space. In reality, the true solution space is unknown and the effect of particular requirements on that solution space is a guessing game. Therefore, we want to propose a process chain that formally includes requirements in the system design process and generates an executable system model. Requirements documented as structured text are mapped into the logic space. Temporal logic allows generation of consistent static state machines. Extracting and modelling input/output signals of that state machine enables us to generate an executable system model, fully derived from its requirements. This bridges the existing gap between requirements specification and system design. The correctness and usefulness of this approach is shown in a case study on automotive systems at Daimler AG.

Paper Nr: 3
Title:

From Manual to Machine-executable Model-based Systems Engineering via Graph-based Design Languages

Authors:

Benedikt Walter, Dennis Kaiser and Stephan Rudolph

Abstract: Today, Model-Based Systems Engineering (MBSE) is widely used in the successful design of complex systems in various industries. It intends to provide a complete description of the design process of complex systems in form of a V-Model or one of its various extensions thereof (extended V-Model). While already several formal languages like Unified Modelling Language (UML) and Systems Modelling Language (SysML) are used to formally describe the design process and behavioural aspects of the design as well, models in UM- or SysML are still mostly assembled and connected manually. Instead, graph-based design languages based on UML make use of the digital representation of the design process with the additional benefit of a repeatable execution encoded in an activity diagram within a rule set. This allows for a seamless transformation of a formerly mainly manual MBSE-approach towards a fully automated, machine-executable MBSE approach. The article will focus on the impact of graph-based design on that transition from classical MBSE towards machine-executable MBSE. We show this with the example of an automotive dashboard.

Paper Nr: 8
Title:

Virtual Prototyping of Large-scale IoT Control Systems using Domain-specific Languages

Authors:

Jacques Verriet, Lennart Buit, Richard Doornbos, Bas Huijbrechts, Kristina Ševo, Jack Sleuters and Mark Verberkt

Abstract: IoT applications and other distributed control applications are characterized by the interaction of many hardware and software components. The inherent complexity of the distributed functionality introduces challenges on the detection and correction of issues related to functionality or performance, which are only possible to do after system prototypes or pilot installations have been built. Correcting these issues is typically very expensive, which could have been avoided by earlier detection. This paper makes four main contributions. (1) It presents a virtual prototyping approach to specify and analyze distributed control applications. The approach is based on a domain model, which can be configured for a specific application. It consists of eight domain-specific languages (DSLs), each describing one system aspect. (2) The DSLs provide each stakeholder in the application’s lifecycle a natural and comprehensible way to describe his/her concerns in an unambiguous manner. (3) The paper shows how the DSLs are used to automatically detect common configuration errors and erroneous behavior. (4) The virtual prototyping approach is demonstrated using a lighting domain case study, in which the control system of an office floor is specified and analyzed.

Paper Nr: 13
Title:

Using fUML Combined with a DSML: An Implementation using Papyrus UML/SysML Modeler

Authors:

Maurice Theobald and Jérémie Tatibouet

Abstract: The definition of standards is an efficient way to ensure a consensus on concepts and usages for a given domain. Unified modeling language (UML) and System modeling language (SysML) are standards: UML provides a large set of concepts enabling the specification of software-oriented systems meanwhile SysML specializes UML for system engineering. Both languages have an accurate semantics, this is especially true for UML which has a subset of objects (classes, composite structures, activities and state machines) that can be executed. Executable UML is driven by the following standards: Foundational subset for executable UML (fUML), precise semantics of UML composite structure (PSCS) and precise semantics of UML state machines (PSSM). From the UML based standard contributor standpoint, there is a great temptation to conclude that system architects can use these standards easily to model complex systems, and run simulations. Unfortunately, in practice, this assumption hardly ever holds. Indeed, these standards are built to be generic enough to apply for the largest possible set of systems. This implies that their scopes are wider than what is required by a user to work in its domain. This problem is solved by using and specializing (if required) a subset of these generic languages to match the needs. This paper shows how to reuse the power of UML, SysML, fUML, PSCS and PSSM efficiently, with a customized version of Papyrus dedicated to system architecture design.

Paper Nr: 17
Title:

Interactive Visualization of Differences between Software Model Versions

Authors:

Jakub Ondik and Karol Rástočný

Abstract: During the development of software systems, various software models are created in the software design phase. The models are being further modified not only by customers’ changes in system requirements, but as well by design decisions based on problems being solved. These changes are sometimes not visible without previous familiarity with original versions of software models, which can cause loss of efficiency not only for software analysts, but also for developers, who must reflect these modifications into source code. The solution to these problems can be found in the proposed method for visualization of modifications in software models, which visualizes modifications directly in diagrams and supports interaction with the modifications. As the basis for the difference detection, we propose an extendible modelling architecture. We evaluate this architecture and the proposed method via working prototype which compares two model versions given in XMI form and visualizes their differences. The evaluation proves that our method significantly shortens time necessary to detect differences by developers and also decreases a number of unidentified differences.

Paper Nr: 22
Title:

Categorical Modeling Method, Proof of Concept for the Petri Net Language

Authors:

Daniel-Cristian Crăciunean

Abstract: Modeling increases the importance of processes significantly, but also imposes higher requirements for the accuracy of process specifications, since an error in the design of a process may only be discovered after it already produces large cumulative losses. We believe that modeling tools can help build better models in a shorter time. This inevitably results in the need to build formal models that can be theoretically verified. A category as well as a model is a mixture of graphical information and algebraic operations. Therefore, category language seems to be the most general to describe the models. The category theory offers an integrated vision of the concepts of a model, and also provides mechanisms to combine models, mechanisms to migrate between models, and mechanisms to build bridges between models. So, category theory simplifies how we think and use models. In this paper we will use the language offered by the category theory to formalize the concept of Modeling Method with the demonstration of the Categorical Modeling Method concept for the Petri Net grammar.

Paper Nr: 26
Title:

Towards Automated fUML Model Verification with Petri Nets

Authors:

Francesco Bedini, Ralph Maschotta, Alexander Wichmann and Armin Zimmermann

Abstract: One of the goals of the Foundational UML Subset (fUML) is a consistent and well-defined execution of UML activity diagrams. However, the specification is not done in a formal mathematical model and leaves room for implementation-specific tool details. This paper shows how this may lead to problems for concurrent program semantics. To this end, the paper introduces a transformation and basic analysis methods for activity diagrams under the current fUML sequential execution semantics. The analysis is conducted using Petri nets, which are mathematical models with a graphical representation to describe distributed systems. There are numerous well-established analysis methods to validate specific desirable properties of a concurrent program including liveliness, the absence of deadlocks, fairness, mutual exclusion, and detection of unreachable states. In this paper, we show that the intuitive translation to Petri nets does not fit the current fUML execution implementation; therefore, we introduce a new model-to-model transformation realized with QVTo, that translates a set of the most used fUML elements to Petri nets. Moreover, we propose methods to analyze the models with the tool TimeNET.

Paper Nr: 27
Title:

Conceptual Story Modeling and Model-driven Architecture for Story Creation

Authors:

Hongxing Liu, Jiali Sun, Shiyu Wang, Qing Yang and Yonghua Li

Abstract: Novels, movies and other genres of stories are popular. This paper studies the methods of computer-aided story creation by means of domain-specific conceptual modeling and model-driven architecture. Firstly, a new conceptual modeling language for story is presented, and its abstract syntax and concrete syntax are defined. The conceptual story model is a kind of graphical, highly abstract, and genre-independent model that describes the events, characters, settings, and the relationships in a given world. We developed a software tool to support the conceptual modeling. Secondly, a model-driven architecture for story creation is proposed, which consists of a series of related models, languages, and tools to support the modeling and transformation. In the architecture, a story work is represented by story models, and the story creation becomes a modeling process from abstract to concrete. We take the genre of story as the platform, so the conceptual model is a platform-independent model, which can be transformed to various platform-specific models. We believe the architecture is a new way for story creation and can make sense for the creative industry.

Paper Nr: 29
Title:

A Metamodel and Model-based Design Rule Checking DSL for Verification and Validation of Electronic Circuit Designs

Authors:

Adrian Rumpold and Bernhard Bauer

Abstract: Development of embedded systems depends on both software and hardware design activities. Quality management of development artifacts is of crucial importance for the overall function and safety of the final product. This paper introduces a metamodel and model-based approach and accompanying domain-specific language for validation of electronic circuit designs. The solution does not depend on any particular electronic design automation (EDA) software, instead we propose a workflow that is integrated into a modular, general-purpose model analysis framework. The paper illustrates both the underlying concepts as well as possible application scenarios for the developed validation domain-specific language, MBDRC (Model-Based Design Rule Checking). It also discusses fields for further research and transfer of the initial results.

Paper Nr: 33
Title:

Towards Applying a Model Driven Approach to Generate Gamified Graphical User Interfaces

Authors:

Sarra Roubi

Abstract: Context: Model Driven approaches were introduced to help provide models, transformations between different levels, and code generators to deal with several issues in software development. These approaches help reduce time in the coding phase along with targeting higher level of abstractions to deal with all the cases. Along with developement in software areas, gamified graphical user interfaces are used in several domain, including business. Indeed, it helped reaching new goals such as descovering new talents or even motivating employees. Objective : In this paper, we present a new model driven approach, starting from a high abstraction level which is platform independent models to reach code genenrating of gamified graphical user interface. Starting from a high level, such as Platform Independent Model (PIM), helps software developers to focus mostly on business knowledge and less about technical details of the targeted platform. Results: The paper presents an end-to-end approach including proposed metamodel and mappings between their elements developed using Eclipse Modeling Framework (EMF) tools and Acceleo for code generation.

Paper Nr: 41
Title:

OntoIFML: Automatic Generation of Annotated Web Pages from IFML and Ontologies using the MDA Approach: A Case Study of an EMR Management Application

Authors:

Naziha Laaz and Samir Mbarki

Abstract: The Semantic Web is a complex ecosystem that integrates a set of software devices necessary to model, disseminate and exploit the knowledge stored in an ontology. The development of its applications is not an easy task, it is costly and time-consuming. It consists of the different design and modeling phases and subphases, each with its own modeling language. Among its most delicate development phases, ontology modeling is mentioned, as well as, the integration of semantic annotations in web pages. In this paper, we present OntoIFML a new MDA-based approach used as an IFML-based tools plugin to facilitate the development of web applications relying on Semantic web paradigm. With this approach, we explore the possibilities for automating the generation of domain ontologies and interfaces annotated by semantic vocabularies from the front-end IFML model. The approach is illustrated by an EMR management application. The result obtained have shown the effectiveness of our approach.

Paper Nr: 48
Title:

A Semantic Analysis of Interface Description Models of Heterogeneous Vehicle Application Frameworks: An Approach Towards Synergy Exploration

Authors:

Sangita De, Michael Niklas, Jürgen Mottok and Přemek Brada

Abstract: As the world is getting more connected, the demands of services in automotive industry are increasing with the requirements such as IoT (Internet of Things) in cars, automated driving, etc. Eventually, the automotive industry has evolved to a complex network of services, where each organization depends on the other organizations, to satisfy its service requirements in different phases of the vehicle life cycle. Because of these heterogeneous and complex development environments, most of the vehicle component interface models need to be specified in various manifestations to satisfy the semantic and syntactic requirements, specific to different application development environments or frameworks. This paper describes an approach to semantic analysis of components interfaces description models of heterogeneous frameworks, that are used for vehicle applications. The proposed approach intends to ensure that interface description models of different service-based vehicle frameworks can be compared, correlated and re-used based on semantic synergies, across different vehicle platforms, development environments and organizations. The approach to semantic synergy exploration could further provide the knowledge base for the increase in interoperability, overall efficiency and development of an automotive domain specific general software solutions, by facilitating coexistence of components of heterogeneous frameworks in the same high-performance ECU for future vehicle software.

Paper Nr: 52
Title:

IML: Towards an Instructional Modeling Language

Authors:

Eric J. Rapos and Matthew Stephan

Abstract: Existing software modeling languages and tooling often contain features far beyond the comprehension of novice users. Additionally, tools focus on specific aspects of the model-driven software engineering (MDSE) process with little to no connection between various tools, phases, and applications. This paper describes our current work and project plans to develop a single modeling language that is aimed at teaching MDSE at the university level. The Instructional Modeling Language (IML), which implements both graphical and textual modeling paradigms, centres around a single tool that includes functionality for various modeling techniques and is not bloated with the full functionality that has been demonstrated to cause students to become overwhelmed when introduced to numerous tools at once. IML includes and describes crucial MDSE concepts and learning milestones including functionality for meta-modeling, instance creation, model transformations, real-time system modeling, code generation, model-based testing, and others. Ultimately, our goal is for IML to be used by instructors to introduce MDSE into their curriculum in a lightweight, easy-to-instruct manner. This includes industrial education to introduce employees with little or no modeling experience to MDSE concepts and applications. In this paper, we describe our plans for developing IML through four phases, our current progress including IML’s scope and meta-model, our prototype, and future plans and anticipated challenges. Our hope is to continue engaging the MDSE community at the conference for feedback, suggestions, and for volunteers for case study and trial adoption.

Paper Nr: 73
Title:

EMFeR: Model Checking for Object Oriented (EMF) Models

Authors:

Christoph Eickhoff, Martin Lange, Simon-Lennert Raesch and Albert Zündorf

Abstract: For safety critical systems it is desirable to be able to prove system correctness. If your system is based e.g. on statecharts or finite automata you may use model checking techniques as provided e.g. by Spin. If your system uses dynamic object models you may use tools like Alloy or graph based tools like Groove, Henshin, or SDMLib. Unfortunately, most of theses approaches use proprietary languages for the specification of models and model transformations. This has the drawback that in order to verify system properties one has to recode the system and its operations within the specific language of the used verification tool. This is tedious and error prone. After a successful verification within the specific tool, you still do not know whether your actual implementation works correct. To overcome these limitations, this paper outlines our new EMFeR (EMF Engine for Reachability) tool. EMFeR provides complete testing and model checking capabilities for EMF based models. Unlike most other systems, EMFeR uses directly the code of the system under test. You just hand your implementation of the employed model operations to EMFeR as lambda expressions. In addition, you provide some model queries to retrieve model elements to be operated on. Thus, you may implement your system’s model operation in plain Java, in Kotlin, in Groovy or whatever and than you may use EMFeR to model check your actual system implementation.