MODELSWARD 2016 Abstracts


Area 1 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 9
Title:

Bidirectional Transformations with QVT-R: A Case Study in Round-trip Engineering UML Class Models and Java Source Code

Authors:

Sandra Greiner, Thomas Buchmann and Bernhard Westfechtel

Abstract: Model-driven software engineering has become more and more important during the last few years. Model transformations constitute the core essence of model-driven development. Throughout the years, the concept of unidirectional model transformations and corresponding tool support has become mature and usable. Transformations of this kind are widely used in model-driven development, for forward or reverse engineering or mainly for code generation. Bidirectional transformations, on the other hand, aim to provide support for (incrementally) transforming one or more source models to one or more target models and vice versa from only one transformation description. However, they seem to be rarely used in model-driven software development although modelers need round-trip support between the different stages of development models. In this paper we present a QVT implementation of a bidirectional model transformation. Our case study keeps UML class diagrams consistent with a Java model during round-trip engineering and thereby shows a real world application. The results and experiences gained in this case study are discussed in detail.

Paper Nr: 10
Title:

Survey on Textual Notations for the Unified Modeling Language

Authors:

Stephan Seifermann and Henning Groenda

Abstract: The Unified Modeling Language (UML) has become the lingua franca of software description languages. Textual notations of UML are also accessible for visually impaired people and allow a more developer-oriented and compact presentation. There are many textual notations that largely differ in their syntax, coverage of the UML, user editing experience, and applicability in teams due to the lack of a standardized textual notation. The available surveys do not cover the academic state of the art, the editing experience and applicability in teams. This implies heavy effort for evaluating and selecting notations. This survey identifies textual notations for UML that can be used instead of or in combination with graphical notations, e.g. by collaborating teams or in different contexts. We identified and rated the current state of 16 known notations plus 15 notations that were not covered in previous surveys. 20 categories cover the applicability in engineering teams. No single editable textual notation has full UML coverage. The mean coverage is 2.7 diagram types and editing support varies between none and 7 out of 9 categories. The survey facilitates the otherwise unclear notation selection and can reduce selection effort.

Paper Nr: 11
Title:

Generating Metamodel Instances Satisfying Coverage Criteria via SMT Solving

Authors:

Hao Wu

Abstract: One of the challenges for using metamodels in Model Driven Engineering is to automatically generate metamodel instances. Each instance should satisfy many constraints defined by a metamodel. Such instances can then be used for verifying or validating metamodels. Recent studies have already shown that this can be tackled by using SAT/SMT solvers. However, such instance generation does not take coverage criteria into account, and instances satisfying specified coverage criteria could be useful for testing model transformation. In this paper, we present an approach consisting of two techniques for coverage oriented metamodel instance generation. The first technique realises the standard coverage criteria defined for UML class diagrams, while the second technique focuses on generating instances satisfying graph-based criteria. With our approach, both kinds of criteria are translated to SMT formulas which are then investigated by an SMT solver. Each successful assignment is then interpreted as a metamodel instance that provably satisfies a coverage criteria or a graph property. We have already integrated this approach into our existing tool to demonstrate the feasibility.

Paper Nr: 23
Title:

A Controlled Experiment for Evaluating the Comprehensibility of UML Action Languages

Authors:

Omar Badreddin, Maged Elaasar and Wahab Hamou-Lhadj

Abstract: Action Languages represent an emerging paradigm where modeling abstractions are embedded in code to bridge the gap with visual models, such as UML models. The paradigm is gaining momentum, evident by the growing number of tools and standards that support this paradigm. In this paper, we report on a controlled ex-periment to assess the comprehensibility of those languages and compare it to that of object-oriented (OO) programming languages. We further report on the impact of also having access to the UML notation on the comprehensibility of those languages. Results suggest that action languages are significantly more comprehen-sible than traditional OO languages. Furthermore, there was not a significant improvement in comprehensibil-ity when the UML notation was used along with both OO and action language code. We conclude that action languages are a promising alternative to traditional OO languages for specifying details, yet seem to be as comprehensible as high-level visual models.

Paper Nr: 24
Title:

Modelling Business Process Variants using Graph Transformation Rules

Authors:

Christine Natschläger, Verena Geist, Christa Illibauer and Robert Hutter

Abstract: Business process variability is an active research area in the field of business process management and deals with variations and commonalities among processes of a given process family. Many theoretical approaches have been suggested in the last years; however, practical implementations are rare and limited in their functionality. In this paper, we propose a new approach for business process variability based on well-known graph transformation techniques and with focus on practical aspects like definition of variation points, linking and propagation of changes, as well as visual highlighting of differences in process variants. The suggested concepts are discussed within a case study comprising two graph transformation systems for generating process variants; one supports variability by restriction, the other supports variability by restriction and by extension. Both graph transformation systems are proven to be globally deterministic, but differ regarding their complexity. The overall approach is being implemented in the BPM suite of our partner company.

Area 2 - Applications and Software Development

Full Papers
Paper Nr: 35
Title:

An Empirical Study on the Impact of Scrumban on Geographically Distributed Software Development

Authors:

Ahmad Banijamali, Research Dawadi, Muhammad Ovais Ahmad, Jouni Similä, Markku Oivo and Kari Liukkunen

Abstract: Coordination in software projects is a challenge, particularly when it comes to distributed software development (DSD). Agile software development is a well-known paradigm for improving software development; however, there is little understanding of its impact on DSD projects. This paper describes an empirical study conducted within two Software Factory settings in Finland and Italy to investigate how Scrumban can impact coordination in geographically distributed software development. It provides the results from a project case that applied Scrumban to develop a web-based application for Time-banking. This study shows that aspects of Scrumban, such as iterative development, enhanced visibility, and limited work-in-progress, would alleviate the challenges of leveraging resources, synchronization between distributed sites, communication, and culture. It also explains that technical and security issues in the coordination of distributed projects may demand for solutions other than Scrumban.

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 36
Title:

Choreography Modelling in Embedded Systems Domain - Requirements and Implementation Technologies

Authors:

Nebojša Taušan, Jouni Markkula, Pasi Kuvaja and Markku Oivo

Abstract: Software companies that develop embedded systems following the principles of service-oriented architecture can anticipate various benefits from choreography modelling. Current choreography modelling languages, however, have a limited applicability in embedded systems development since they are not expressive enough to capture all the choreography-relevant aspects that are typical in this domain. We tackled this problem by analysing the needs of embedded systems for choreography modelling language. Our analysis was guided by design science and relied on expert interviews, company-specific documents and the relevant literature. The main results of the analysis presented in this paper are a) design requirements addressing the limitations of choreography modelling languages for embedded systems development and b) proposals for modelling language implementation technologies. The feasibility of these results is evaluated by redesigning an existing choreography modelling language and by implementing a prototype editor for the redesigned language.

Paper Nr: 37
Title:

WebDPF: A Web-based Metamodelling and Model Transformation Environment

Authors:

Fazle Rabbi, Yngve Lamo, Ingrid Chieh Yu and Lars Michael Kristensen

Abstract: Metamodelling and model transformation play important roles in model-driven engineering as they can be used to define domain-specific modelling languages. During the modelling phase, modellers encode domain knowledge into models which may include both structural and behavioral aspects of a system. The contribution of this paper is a new web-based metamodelling and model transformation tool called WebDPF based on the Diagram Predicate Framework (DPF). WebDPF supports multilevel diagrammatic metamodelling and specification of model constraints, and it supports diagrammatic development and analysis of model transformation systems. We show how the support for model transformation systems in WebDPF can be exploited to (i) support auto-completion of partial models thereby enhancing modelling efficiency, and (ii) provide execution semantics for workflow models. Furthermore, we illustrate how WebDPF incorporates a scalable model navigation facility designed to enable users to inspect and query large models.

Paper Nr: 47
Title:

Formal MOF Metamodeling and Tool Support

Authors:

Liliana Favre and Daniel Duarte

Abstract: Model Driven Development (MDD) has emerged as a new road to software development industrialization. The most well-known realization of MDD is the Model Driven Architecture (MDA). The essence of MDA is the metamodel MOF (Meta Object Facility) allowing interoperability of different kind of artifacts from multiple technologies. It is important to formalize and reason about MOF metamodels properly. In this paper, we propose a rigorous framework for reasoning about “correctness” of metamodels. Our main contribution is the integration of MOF metalanguage with formal specification languages based on the algebraic formalism. We define NEREUS, a formal metamodeling language, and processes for reasoning about MOF-like metamodels such as ECORE metamodels. The paper describes a set of tools developed to make formal metamodeling feasible in practice.

Area 4 - Applications and Software Development

Full Papers
Paper Nr: 49
Title:

Verification of Atomicity Preservation in Model-to-Code Transformations using Generic Java Code

Authors:

Dan Zhang, Dragan Bosnacki, Mark van den Brand, Cornelis Huizing, Ruurd Kuiper, Bart Jacobs and Anton Wijs

Abstract: A challenging aspect of model-to-code transformations is to ensure that the semantic behavior of the input model is preserved in the output code. When constructing concurrent systems, this is mainly difficult due to the non-deterministic potential interaction between threads. In this paper, we consider this issue for a framework that implements a transformation chain from models expressed in the state machine based domain specific language SLCO to Java. In particular, we provide a fine-grained generic solution to preserve atomicity of SLCO statements in the Java implementation. We give its generic specification based on separation logic and verify it using the verification tool VeriFast. The solution can be regarded as a reusable module to safely implement atomic operations in concurrent systems.

Area 5 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 61
Title:

K: A Wide Spectrum Language for Modeling, Programming and Analysis

Authors:

Klaus Havelund, Rahul Kumar, Chris Delp and Bradley Clement

Abstract: The formal methods community has over the years proposed various formally founded specification languages based on predicate logic and set theory. At the same time the model-based engineering community has pro- posed less formally founded graphical formalisms such as UML and SysML. We report on an effort to formally ground SysML in a textual formal language, named K, supporting classes, multiple inheritance, predicate logic and set theory. K contains programming constructs, and can thus be considered as a wide-spectrum modeling and programming language. We further explain the translation of a subset of this textual language to the input language of the SMT-LIB standard, and the application of Z3 for analysis of the generated SMT-LIB formu- las. The entire effort is part of a larger effort to develop a general purpose SysML development framework for designing systems, in support of NASA’s proposed 2022 mission to Jupiter’s moon Europa.

Area 6 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 66
Title:

Model-driven Approach for Verifying Conformity of Models in the Presence of Constraints

Authors:

César Cuevas Cuesta, Patricia López Martínez and José M. Drake

Abstract: This paper presents a model-driven approach for the systematic development of tools for checking the conformity of models when the domain formalization does not only consist of a meta-model but also on a set of constraints enhancing it. The strategy is built on top of the idea of representing the result of the verification as a model which gathers all the constraint violations found in the model, formulating them in a way that allows their later detailed manifestation, automatic correction or any other potential processing. With that aim, a meta-model for supporting those models describing constraints violations has been designed. The verification is applied by means of an M2M transformation that takes as input the model to verify and generates a model conforming to the designed meta-model. This methodology constitutes the way to accomplish the final objective: designing a strategy for the development of a generic tool for verification, regardless any particular meta-model or constraints set. This is performed through the duality of a model transformation as a processing program but also as a processed artefact (model), by means of the Higher Order Transformation (HOT) technique.

Area 7 - Applications and Software Development

Full Papers
Paper Nr: 68
Title:

UML Associations - Reducing the Gap in Test Coverage between Model and Code

Authors:

Anders Eriksson and Birgitta Lindström

Abstract: This paper addresses the overall problem of estimating the quality of a test suite when testing is performed at a platform-independent level, using executable UML models. The problem is that the test suite is often required to fulfill structural code coverage criteria. In the avionics domain it is usually required that the tests achieve 100% coverage according to logic-based coverage criteria. Such criteria are less effective when applied to executable UML models than when they are applied to code because the action code found in such models contains conditions in navigation and loops that are not explicit and therefore not captured by logic-based coverage criteria. We present two new coverage criteria for executable UML models, and we use an industrial application from the avionics domain to show that these two criteria should be combined with a logic-based criterion when testing the executable UML model. As long as the coverage is less than 100% at the model level, there is no point in running the tests at the code level since all functionality of the model is not yet tested, and this is necessary to achieve 100% coverage at the code level.

Area 8 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 77
Title:

Automating Activities in MDE Tools

Authors:

Miguel Andrés Gamboa and Eugene Syriani

Abstract: Model-Driven Engineering (MDE) is a victim of its own success: being able to quickly generate software tools, many modeling tools exist today, but their usability is far from efficient. Complex processes and repetitive tasks are often required to perform a modeling activity, such as creating a domain-specific language or creating a domain-specific model. The goal of this paper is to increase the productivity of modelers in their every day activities by automating the tasks they perform in current MDE tools. We propose an MDE-based solution where the user defines a workflow that can be parametrized at run-time and executed. Our solution works for frameworks that support two level metamodeling as well as deep metamodeling. We implemented our solution in the MDE tool AToMPM. We also performed a preliminary empirical evaluation of our approach and showed that we reduce both mechanical and cognitive efforts of the user.

Area 9 - Applications and Software Development

Full Papers
Paper Nr: 93
Title:

An Initial Wise Development Environment for Behavioral Models

Authors:

David Harel, Guy Katz, Rami Marelly and Assaf Marron

Abstract: We present a development environment that proactively and interactively assists the software engineer in modeling complex reactive systems. Our framework repeatedly analyzes models of the system under development at various levels of abstraction, and then reasons about these models in order to detect possible errors and to derive emergent properties of interest. Upon request, the environment can then augment the system model in order to repair or avoid detected behavior that is undesired, or instrument it in order to monitor the execution for certain behaviors. Specialized automated and human-assisted techniques are incorporated to direct and prioritize the analysis and related tasks, based on the relevance of the observed properties and the expected impact of actions to be taken. Our development environment is an initial step in the direction of the very recent Wise Computing vision, which calls for turning the computer (namely, the development environment) into an equal member of the development team: knowledgeable, independent, concerned and proactively involved in the development process. Our tool is implemented within the context of behavioral programming (BP), a scenario-based modeling approach, where components are aligned with how humans often describe desired system behavior. Thus, our work further enhances the naturalness and incrementality of developing in BP.

Short Papers
Paper Nr: 8
Title:

From Model to Rig – An Automotive Case Study

Authors:

Josefine Södling, Rikard Ekbom, Peter Thorngren and Håkan Burden

Abstract: As the size and complexity of the software in a truck grows, new ways of managing the development are needed. Numerous reports show how MDE can be successfully applied for automotive software development. We complement previous research by conducting a case study on the impact of model-based testing for verifying and validating the behaviour of a truck’s headlights. Our results are three-fold. First, we show how a model can be transferred from a model-in-the-loop setting to a hardware-in-the-loop via system simulation. Second, we supply an analysis of the shortcomings of the model that were found as the model was tested in more and more platform-specific settings. Third, our results show that the introduction of model-based testing practices will require organisational changes even if the used tools are familiar to the company.

Area 10 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 12
Title:

Extending Graphical Part of the Interaction Flow Modeling Language to Generate Rich Internet Graphical User Interfaces

Authors:

Sarra Roubi, Mohammed Erramdani and Samir Mbarki

Abstract: Rich Internet Applications (RIAs) combine the simplicity of the hypertext paradigm with the flexibility of desktop interfaces. However, RIAs are complex applications and their development requires designing and implementation which are time-consuming and the available tools are specialized in manual design. In this paper, we present an approach for the model driven generation of Rich Internet Application using the Interaction Flow Modeling Language (IFML). The approach exploits the new language IFML recently adopted by the Object Management Group by extending first the graphical part of the Meta Model to fit the RIAs’ needs. We used frameworks and technologies known to model-driven engineering, such as Eclipse Modeling Framework (EMF) for Meta Models, Query View Transformation (QVT) for model transformations and Acceleo for code generation. The approach allows to quickly and efficiently generating a RIA focusing on the graphical aspect of the application.

Area 11 - Applications and Software Development

Short Papers
Paper Nr: 15
Title:

Generic and Distributed Runtime Environment for Model-driven Game Development

Authors:

Sebastian Apel and Volkmar Schau

Abstract: Massive multiplayer online games are large-scaled distributed systems to handle a huge amount of simultaneous players. Thus, development costs can be enormous. To deal with this, it is necessary to reduce redundant development steps in such distributed systems, e.g. by using code generators and model analysers to build components from already existing knowledge. Such knowledge could be the unique game logic. This paper reports realized approaches to derivate infrastructure from that logic within our middleware. Getting through this is achieved by using an abstract meta model for game design processes, harvest information from those design results and generate infrastructure for communication, controlling and persistance. Finally we evalutes its applicableness and useablity in multiple game projects.

Area 12 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 18
Title:

Data Integration between Objectiver and DB-Main: A Case Study of a Model-Driven Interoperability Bridge

Authors:

Francisco Javier Bermúdez Ruiz, Jesús Joaquín García Molina and Oscar Díaz García

Abstract: In building software systems, the integration of tools with the purpose of exchanging data (i.e. tool interoperability) is common practice. Such an integration is one of the application scenarios of Model-Driven Engineering (MDE), which is often called Model-Driven Interoperability (MDI). In the last few years, some MDI approaches have been presented, and they have shown how MDE techniques are useful in bridging tools in order to integrate data. However, the number of case studies is still limited and more practical experiences of building MDI bridges should be published. In this article, we present an MDI bidirectional bridge that integrates the Objectiver and DB-Main tools. DB-Main database schemas are obtained from Objectiver object models, and they are kept consistent. Through this case study, we contrast the majority of techniques that can be used to implement a MDI solution. We mainly focus on the level of automation offered by each alternative. Some lessons learned are commented on.

Area 13 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 22
Title:

Systematic Mapping Study of Model Transformations for Concrete Problems

Authors:

Edouard Batot, Houari Sahraoui, Eugene Syriani, Paul Molins and Wael Sboui

Abstract: As a contribution to the adoption of the Model-Driven Engineering (MDE) paradigm, the research community has proposed concrete model transformation solutions for the MDE infrastructure and for domain-specific problems. However, as the adoption increases and with the advent of the new initiatives for the creation of repositories, it is legitimate to question whether proposals for concrete transformation problems can be still considered as research contributions or if they respond to a practical/technical work. In this paper, we report on a systematic mapping study that aims at understanding the trends and characteristics of concrete model transformations published in the past decade. Our study shows that the number of papers with, as main contribution, a concrete transformation solution, is not as high as expected. This number increased to reach a peak in 2010 and is decreasing since then. Our results also include a characterization and an analysis of the published proposals following a rigorous classification scheme.

Paper Nr: 27
Title:

Towards a Common Understanding of Business Process Instance Data

Authors:

Nima Moghadam and Hye-young Paik

Abstract: In an organisation several Business Process Management System (BPMS) products can co-exist and work alongside each other. Each one of these BPM tools has its own definition of process instances, creating a heterogeneous environment. This reduces interoperability between business process management systems and increases the effort involved in analysing the data. In this paper, we propose a common model for business process instances, named Business Process Instance Model (BPIM), which provides a holistic view of business process instances generated from multiple systems. BPIM consists of visual notations and their metadata schema. It captures three dimensions of process instances: process execution paths, instance data provenance and meta-data. BPIM aims to provide an abstract layer between the process instance repository and BPM engines, leading to common understanding of business process instances.

Paper Nr: 29
Title:

Translating Task Models to State Machines

Authors:

Andreas Wagner and Christian Prehofer

Abstract: We present a new method to translate the established and well-known ConcurTaskTree (CTT) task modeling technique into state machines. For this purpose, we develop the concepts of partial state machines, Connectables and a connect operator, which form the theoretical framework for a new algorithm. For the translation, we develop and present a recursive, bottom-up algorithm, which exploits the inherent structure of CTTs and produces valid, partial state machines. This allows new development processes in the model-driven application and system development domain.

Paper Nr: 43
Title:

Automating the Construction of Models based on Domain Views

Authors:

César Cuevas Cuesta, Patricia López Martínez and José M. Drake

Abstract: This work addresses the automatic generation of the resources required for the assisted creation of domain models according to specialized views of their meta-model. The task of a designer who builds models compliant to a complex domain meta-model is eased if the model editor requests the information according to a specific view of the meta-model based on the conceptualization or the specific construction strategy that the designer uses. With that aim, this work presents 1) the meta-model with which a domain expert formulates the model creation strategy that he envisions, 2) the tool that, from that strategy information, generates the meta-model that drives data introduction and 3) the M2M transformation that generates the final model compliant to the original domain meta-model and that contains the newly introduced data.

Paper Nr: 45
Title:

Enabling Data Flows in UML Interactions

Authors:

Marc-Florian Wendland, Ramon Barakat and Martin Schneider

Abstract: UML Interactions represent one of the three UML behaviors. They describe the interwork of parts of a system based on message exchange. UML Interactions can reside on any level of abstraction and they seem sufficiently elaborated for high-level specifications used for sketching the communication among parts of a system. The UML Interactions metamodel, however, reveals some deficiencies for precise specifications of data values and data flows. Even UML 2.5 still does not provide concepts for data flows in UML Interactions. In this paper, we suggest a profile-based extension that integrates data flow concepts with UML Interactions. The extension supports accessing (usage of) values located in data sources and assignment (definition) of values to data sinks in the context of message exchange and invocation of Interactions. The proposed extension improves the expressiveness of UML Interactions in a minimal invasive manner and makes it similar to the capabilities of UML Activities regarding the specification of data flows.

Paper Nr: 50
Title:

Lightweight Realization of UML Ports for Safety-Critical Real-Time Embedded Software

Authors:

Alper Tolga Kocataş, Mustafa Can and Ali Doğru

Abstract: UML ports are widely used in the modeling of real-time software due to their advantages in flexibility and expressiveness. When realizing UML ports in object oriented languages, using objects for each port is one option. However, this approach causes runtime overhead and renders significant amount of additional generated code. To meet the performance constraints and decrease the costs of code reviews required in development of safety-critical real-time embedded software, more efficient approaches are required. In this article, we propose an approach, which introduces relatively less runtime overhead and results in smaller source code. A structural model defined with UML ports is transformed into a model that uses associations instead of objects to efficiently implement the UML port semantics with less lines of code. Achieved improvements and validation of the proposed approach is demonstrated by a case study; the design of an existing avionics software.

Paper Nr: 51
Title:

A New Methodology CIM to PIM Transformation Resulting from an Analytical Survey

Authors:

Yassine Rhazali, Youssef Hadi and Abdelaziz Mouloudi

Abstract: Our paper shows a new methodology for controlling the models transformation from CIM to PIM into model driven architecture. In this proposal we founded on an analytical survey. Our methodology is based on creation of the transformable models in CIM level to facilitate the transformation task to the PIM level. We create a good PIM level, according to the three classic modelling views. Then, a set of transformation rules are established through ATL language to assure a semi-automatic transformation between CIM and PIM. Our methodology ensures the recommendations of MDA approach by presenting business process in CIM level through BPMN which is OMG standard for modelling business process. However, we founded on UML to model the PIM level, because UML is advisable by MDA in PIM.

Area 14 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 63
Title:

Automated Quality Analysis of Software Engineering Method Models

Authors:

Masud Fazal-Baqaie and Frank Kluthe

Abstract: Using a suitable software engineering method (SEM) for a specific project and following it properly is important for the resulting software quality. However, SEMs described in natural language are often ambiguous and lack automated guidance for the team members, causing impediments for the project. The model-based approach Method Engineering with Method Services and Method Patterns (MESP) allows to model enactable SEM models by composing pre-defined building blocks. Up to now, the quality of MESP models had to be checked manually which was tedious and error-prone at times. In this paper, we present an automated design-time quality analysis for MESP SEM models. In particular, our analysis allows to automatically evaluate generic quality characteristics relevant for all SEM models as well as specific quality requirements specified using MESP method patterns. We integrated the quality analysis framework into the MESP Workbench and our evaluation shows that the analysis is fast enough to provide timely feedback even for large SEM models.

Area 15 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 64
Title:

Abstracting Data and Image Processing Systems using a Component-based Domain Specific Language

Authors:

Thomas Hoegg, Christian Koehler and Andreas Kolb

Abstract: This work proposes a textual and graphical domain-specific language (DSL) designed especially for modeling and writing data and image processing algorithms. Since reusing algorithms and other functionality leads to higher program quality and mostly shorter development time, this approach introduces a novel component-based language design. Special diagrams and structures, such as components, component-diagrams and component-instance-diagrams are introduced. The new language constructs allow an abstract and object-oriented description of data and image processing tasks. Additionally, a compatible graphical design interface is proposed, giving modelers and architects the opportunity to decide which kind of modeling they prefer (graphical or textual, including round-trip engineering).

Paper Nr: 65
Title:

The EMF Parsley DSL for Developing EMF Applications

Authors:

Lorenzo Bettini

Abstract: The Eclipse Modeling Framework (EMF) is the official Eclipse modeling framework. It provides code generation facilities for building tools and applications based on structured data models. The Eclipse project EMF Parsley enhances the EMF reflective mechanisms in order to make the development of EMF applications easier by hiding most EMF internal details and by using dependency injection for customizing all the aspects of such applications. In this paper we show the main features of the EMF Parsley DSL that aims at making the development of EMF applications even easier and faster. The DSL is built with Xtext and Xbase, thus it features full Eclipse IDE support and full interoperability with Java.

Paper Nr: 69
Title:

Addressing the Need for Strict Meta-modeling in Practice - A Case Study of AUTOSAR

Authors:

Darko Durisic, Miroslaw Staron, Matthias Tichy and Jörgen Hansson

Abstract: Meta-modeling has been a topic of interest in the modeling community for many years, yielding substantial number of papers describing its theoretical concepts. Many of them are aiming to solve the problem of traditional UML based domain-specific meta-modeling related to its non-compliance to the strict meta-modeling principle, such as the deep meta-modeling approach. In this paper, we show the practical use of meta-models in the automotive development process based on AUTOSAR and visualize places in the AUTOSAR meta-model which are broken according to the strict meta-modeling principle. We then explain how the AUTOSAR meta-modeling environment can be re-worked in order to comply to this principle by applying three individual approaches, each one combined with the concept of Orthogonal Classification Architecture: UML extension, prototypical pattern and deep instantiation. Finally we discuss the applicability of these approaches in practice and contrast the identified issues with the actual problems faced by the automotive meta-modeling practitioners. Our objective is to bridge the current gap between the theoretical and practical concerns in meta-modeling.

Area 16 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 71
Title:

XIS-CMS: Towards a Model-Driven Approach for Developing Platform-Independent CMS-Specific Modules

Authors:

Paulo Filipe, André Ribeiro and Alberto Rodrigues da Silva

Abstract: Content Management Systems (CMS) are popular web application platforms used in multiple domains. CMS allow non-technical users to manage the content and features of websites with web modules that abstract functionality without requiring particular software programming background. However, without the development of specific web modules, a CMS usually cannot support complex scenarios or specific business needs. In those situations, developers have to build custom modules using the CMS-specific language, which implies that they must master the corresponding programming and other technical skills. This paper proposes a model-driven approach, named XIS-CMS, which aims to increase the productivity and portability of developing these modules in a more abstract and platform-independent way. XIS-CMS approach includes a domain-specific modeling language, defined as a UML profile, and a companion framework defined on top of Sparx Systems Enterprise Architect and Eclipse Modeling Framework technologies. This paper introduces the XIS-CMS approach, its corresponding language and framework, and compares it with related work.

Paper Nr: 72
Title:

A Data Extraction Process for Avionics Systems’ Interface Specifications

Authors:

Hassna Louadah, Roger Champagne, Yvan Labiche and Yann-Gaël Guéhéneuc

Abstract: Avionics systems, along with their internal hardware and software components interfaces, must be well defined and specified (e.g., unambiguous, complete, verifiable, consistent, and traceable specification). Such a specification is usually written in the form of an Interface Control Document (ICD), and represents the cornerstone of the avionics system integration activities. However, there is no commonly accepted language to define and use these ICDs and no common definition of what an ICD is or should contain. Indeed, avionics companies define their own, proprietary ICDs and processes. In this paper, we first identify the pieces of information that an ICD should contain for both federated and IMA open systems. Then, we propose a data extraction process that enables better understanding and more efficient extraction of open avionics systems interface specifications, and provides a clearer vision on the information needed to build a model driven solution for modeling avionics system interfaces, our long-term goal. We validate this process by applying it on a set of open avionics sub-system standards and the results have shown its feasibility.

Area 17 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 75
Title:

SysML Models and Model Transformation for Security

Authors:

Florian Lugou, Letitia W. Li, Ludovic Apvrille and Rabéa Ameur-Boulifa

Abstract: The security flaws of embedded systems have become very valuable targets for cyber criminals. SysML-Sec has been introduced to target the security of these systems during their development stages. However, assessing resistance to attacks during these stages requires efficiently capturing the system’s behavior and formally proving security properties from those behaviors. This paper thus proposes (i) novel SysML block and state machine diagrams enhanced to better capture security features, and (ii) a model-to-Proverif transformation. ProVerif is a toolkit first released for the formal analysis of security protocol, but it can be used more generally to assess confidentiality and authenticity properties. This paper demonstrates the soundness of our approach using a complex asymmetric key distribution protocol.

Paper Nr: 78
Title:

Evaluating the Cloud Architecture of AToMPM

Authors:

Jonathan Corley, Eugene Syriani and Huseyin Ergin

Abstract: In model-driven engineering, stakeholders work on models in order to design, transform, simulate, and analyze systems. Complex systems typically involve many stakeholder groups working in a coordinated manner on different aspects of a system. Therefore, there is a need for collaborative platforms to allow modelers to work together. Previously, we introduced the cloud-based multi-user tool AToMPM, designed to address the challenges for building a collaborative platform for modeling. This paper presents on the multi-user, multi-view architecture of AToMPM and an initial evaluation of its performance and scalability.

Area 18 - Applications and Software Development

Short Papers
Paper Nr: 79
Title:

World Model for Testing Urban Search and Rescue (USAR) Robots using Petri Nets

Authors:

Anneliese Andrews, Mahmoud Abdelgawad and Ahmed Gario

Abstract: This paper describes a model-based test generation approach for testing Urban Search and Rescue (USAR) robots interacting with their environment (i.e., world). Unlike other approaches that assume a static world with attributes and values, we present and test a dynamic world. We use Petri Nets to illustrate a world model that describes behaviors of environmental entities (i.e., actors). The Abstract World Behavioral Test Cases (AWBTCs) are generated by covering the active world model using graph coverage criteria. We also select test-data by input-space partitioning to transform the generated AWBTCs into executable test cases. Reachability of the active world model and efficiency of coverage criteria are also discussed.

Area 19 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 80
Title:

Model-Driven Product Line Engineering for Mapping Parallel Algorithms to Parallel Computing Platforms

Authors:

Ethem Arkin and Bedir Tekinerdogan

Abstract: Mapping parallel algorithms to parallel computing platforms requires several activities such as the analysis of the parallel algorithm, the definition of the logical configuration of the platform, the mapping of the algorithm to the logical configuration platform and the implementation of the source code. Applying this process from scratch for each parallel algorithm is usually time consuming and cumbersome. Moreover, for large platforms this overall process becomes intractable for the human engineer. To support systematic reuse we propose to adopt a model-driven product line engineering approach for mapping parallel algorithms to parallel computing platforms. Using model-driven transformation patterns we support the generation of logical configurations of the computing platform and the generation of the parallel source code that runs on the parallel computing platform nodes. The overall approach is illustrated for mapping an example parallel algorithm to parallel computing platforms.

Paper Nr: 81
Title:

Towards a Model Transformation Tool on the Top of the OpenCL Framework

Authors:

Tamás Fekete and Gergely Mezei

Abstract: Nowadays, applications must often handle a large amount of data and apply complex algorithms on it. It is a promising and popular way to apply the computation in parallel in order to meet the performance requirements. Since GPUs are designed to apply highly parallel computations efficiently, using CPU+GPU heterogeneous architecture have gained an increasing popularity in computation intensive applications. Model-driven development (MDE) is a widely used software development methodology in the software industry. MDE is heavily building on model transformations in converting and processing the models. Graph transformation-based model transformation is a popular technique in this field. It is based on isomorphic subgraphs matching, which often require serious computing power. Currently, model transformation tools are not capable of using the computation power of the GPUs. Our research goal is to create a general model matching and later a model transformation solution, which can take the advantages of the computation power of the GPUs. We are now focusing on pattern matching of the transformations. We would like to create a general solution which is independent of the hardware vendor; therefore, our method is based on the OpenCL framework. The novelty of this paper is a GPGPU-based pattern matching tool and some accelerating techniques to achieve faster computation. In this paper we present an overview of the solution and test results based on one of the biggest freely available movie database (IMDb). The main properties such as the performance and the scalability are discussed. The applied architecture and the steps towards the final solution are also included in the paper.

Paper Nr: 84
Title:

Towards Statistical Comparison and Analysis of Models

Authors:

Önder Babur, Loek Cleophas, Tom Verhoeff and Mark van den Brand

Abstract: Model comparison is an important challenge in model-driven engineering, with many application areas such as model versioning and domain model recovery. There are numerous techniques that address this challenge in the literature, ranging from graph-based to linguistic ones. Most of these involve pairwise comparison, which might work, e.g. for model versioning with a small number of models to consider. However, they mostly ignore the case where there is a large number of models to compare, such as in common domain model/metamodel recovery from multiple models. In this paper we present a generic approach for model comparison and analysis as an exploratory first step for model recovery. We propose representing models in vector space model, and applying clustering techniques to compare and analyse a large set of models. We demonstrate our approach on a synthetic dataset of models generated via genetic algorithms.

Paper Nr: 89
Title:

ImocaGen: A Model-based Code Generator for Embedded Systems Tuning

Authors:

Goulven Guillou and Jean-Philippe Babau

Abstract: IMOCA is a model-based architecture model dedicated to embedded process control systems in disturbed environment. These systems depend on various parameters which are difficult to set because they are bound to environment changes. In this paper we propose to extend IMOCA with the meta-model ImocaGen for managing the aspects of the code generation. ImocaGen allows to target multiple platforms and different programming languages, generates both embedded code as well as tuning and reconfiguration tools, takes into account different communication protocols and offers a mechanism for integrating handwritten code. This approach is tested on a basic control application for a NXT brick for which three generations are performed: the first one for a PC with an USB connection, the second one for an Android tablet with a Bluetooth connection and the last one for a simulator in Java.

Paper Nr: 91
Title:

A Demonstration of Compilability for UML Template Instances

Authors:

José Farinha

Abstract: Because of the thin set of well-formedness rules associated to Templates in UML, ill-formed elements may result from bindings to templates. Although such ill-formedness is generally detected by some UML validation rule, the problem is poorly reported because it is not normally imputed to the binding. Typically, such problems are detected as non-compilable code in the template instances. A set of well-formedness rules, additional to those of the standard UML, was proposed as a way to ensure the compilability of instances and prevent this problem from occurring. Such set of constraints was proposed in a previous paper and named \emph{Functional Conformance}, but a demonstration of its effectiveness was not yet provided. Such a demonstration is outlined in the current paper. Carrying out the demonstration revealed the need for two more rules than those previously envisioned for \emph{Functional Conformance}.

Paper Nr: 92
Title:

Towards Executable UML Interactions based on fUML

Authors:

Marc-Florian Wendland

Abstract: Executable specifications for UML currently comprise fUML, precise semantics of composite structures and in future precise semantics for state machines. An executable semantics for UML Interactions is on the roadmap, but has not been addressed by the OMG Executable UML working group so far. Interactions are said to be the second most used diagrams after class diagram of UML, thanks to their comprehensibility and illustrative visualization. Unfortunately, they suffer from fuzzy semantics and technical issues that wastes the potential Interactions could have for engineering activities apart from high-level specifications. In this position paper we present first results from experiments and attempts to map UML Interactions to fUML Activities in order to eventually execute them.

Paper Nr: 94
Title:

Towards Hybrid Semantics of Enterprise Modeling Languages

Authors:

Richard Braun and Werner Esswein

Abstract: Enterprise Modeling Languages (EMLs) are generally perceived as conceptual modeling languages having a formal syntax and informal semantics. The non-formality of semantics is mainly caused by the materiality of the addressed domain (enterprises and its related aspects) and the resulting personal interpretation of syntactical constructs. However, EMLs may also explicitly define invariant interpretations in the sense of possible model executions or the definition of domain-specific restrictions. It is therefore promising to address a possible amalgamation of material semantics and formal semantics in order to provide an integrated and comprehensive semantic specification of EMLs. This position paper introduces and motivates the topic by systematizing and consolidating approaches from both fields and introduces a framework for so-called hybrid semantics on the meta model layer. Further, the general relevance of semantics and semantic specifications in EMLs is emphasized and prospective research challenges are proposed.

Paper Nr: 96
Title:

Modelling of Systems for Real

Authors:

Joachim Fischer, Birger Møller-Pedersen and Andreas Prinz

Abstract: Modelling and Programming are often used together in system development. However, typically there is a large difference between the handling of modelling parts and the handling of programming parts. This leads to the fact that the transition between the two is not easy, and important information is lost as well as extra information has to be provided when combining modelling and programming. This paper shows how modelling and programming could work together in system development.

Area 20 - Applications and Software Development

Short Papers
Paper Nr: 97
Title:

What is Software Architecture to Practitioners: A Survey

Authors:

Mert Ozkaya

Abstract: Software architecture has been proposed in the nineties as a high-level software design method for specifying software systems in terms of components and their relation. Since then, software architectures have become an indispensable part of software design. However, it remains dubious to what extent practitioners use software architectures in their software design. To better understand this, we conduct a survey study among a number of practitioners from both industry and academia and aim at understanding their level of knowledge and experience in software architectures. Our survey consists of a questionnaire of 20 questions, presented in four distinct sections. We run our survey on 50 participants, 11 of whom are from academia and the rest 39 are from industry. As a result of our analysis, we reached the following conclusion: while software architecture is highly crucial for practitioners given the nature of their software projects, practitioners’ knowledge on software architectures is too limited. Practitioners use Unified Modelling Language (UML), which views software architectures as a method of communicating system structures. However, other aspects such as architectural analysis are equally crucial in detecting design errors and verifying software designs for quality properties.

Area 21 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 99
Title:

Flexible Component Composition through Communication Abstraction

Authors:

Fabian Gilson and Vincent Englebert

Abstract: Software architectures are often abstracted as a combination of reusable components connected to each other by various means. Specifications of components' semantics have been widely studied and many modeling languages have been proposed from coarse-grained loosely-defined elements to operational objects with behavioral semantics that may be generated and executed in a dedicated framework. All these modeling facilities have proven their advantages in many domains through either case studies or real-world applications. However, most of those approaches either consider a subset of composition facilities, \textit{i.e.} the available types of bindings between components, or do not even consider communication properties at all, staying at behavioral-related compatibility between components. Verifications of communication-related properties are then postponed to the hand of software developers and finally considered at deployment-time only. Part of a general architecture framework, we propose an abstraction formalism to specify communication paths between components. This modeling facility relies on a taxonomy of types of links and the specifications of communication protocols. This protocol serves as a \textit{reification} element between abstract component compositions, architecture instances and deployment infrastructure, making explicit communication-related constraints and properties.

Posters
Paper Nr: 1
Title:

MOF-VM: Instantiation Revisited

Authors:

Terje Gjøsæter, Andreas Prinz and Jan P. Nytun

Abstract: The Model-Driven Architecture (MDA) is based on an understanding of a hierarchy of levels that are placed on top of each other and that are connected with instantiation. For practical MDA use, it is important to be clear about the kinds of objects that reside on the different levels and the relations between them as well as relations to objects outside of the MDA domain. This article aims at enhancing the understanding of these objects and relations by relating them to a virtual MOF machine.

Paper Nr: 6
Title:

An Empirical Study on the Perception of Metamodel Quality

Authors:

Georg Hinkel, Max Kramer, Erik Burger, Misha Strittmatter and Lucia Happe

Abstract: Despite the crucial importance of metamodeling for Model- Driven Engineering (MDE), there is still little discussion about the quality of metamodel design and its consequences in model-driven development processes. Presumably, the quality of metamodel design strongly affects the models and transformations that conform to these metamodels. However, so far surprisingly few work has been done to validate the characterization of metamodel quality. A proper characterization is essential to automate quality improvements for metamodels such as metamodel refactorings. In this paper, we present an empirical study to sharpen the understanding of the perception of metamodel quality. In the study, 24 participants created metamodels of two different domains and evaluated the metamodels in a peer review process according to an evaluation sheet. The results show that the perceived quality was mainly driven by the metamodels completeness, correctness and modularity while other quality attributes could be neglected.

Paper Nr: 7
Title:

Supporting CRUD Model Operations from EOL to SQL

Authors:

Xabier De Carlos, Goiuria Sagardui and Salvador Trujillo

Abstract: Model-based software development promises improvements in terms of quality and cost by raising the abstraction level of the development from code to models, but also requires mature techniques and tools. Although Eclipse Modelling Framework (EMF) introduces a default persistence mechanism for models, namely XMI, its usage is often limited as model size increases. To overcome this limitation, during the last years alternative persistence mechanisms have been proposed in order to store models in RDBMS and NoSQL databases. Under this new paradigm, model operations can be performed at model-level and persistence-level, e.g., mapping EOL model operations into SQL statements. In this paper, we extend our framework (called MQT) to support CRUD (Create, Read, Update and Delete) operations from model- (EOL) to persistence-level (SQL), using a streaming execution of queries at run-time. Through comparable evaluation metrics, we evaluate the performance and memory footprint of the framework using the GraBaTs scenario.

Paper Nr: 14
Title:

Addressing Model Complexity in Automotive System Development - Selection of System Model Elements for Allocation of Requirements

Authors:

Grischa Liebel, Andreea Olaru, Henrik Lönn, Henrik Kaijser, Sunith Rajendran, Urban Ingelsson and Richard Berntsson Svensson

Abstract: Modern automotive embedded systems are developed by Original Equipment Manufacturers (OEM) together with multiple suppliers. A key problem for a supplier is to allocate an OEM's requirements specification to their own subsystem design. This is a difficult manual task especially on complex systems and it requires expert knowledge about the system design. To address this problem, this paper presents a design science research to develop and evaluate a Requirements Allocation Assistant tool (RAA). The tool provides functionality to search through and filter requirements and system models to enable efficient requirements allocation even in the presence of complexity. RAA is built on top of the EATOP/Eclipse framework using EAST-ADL as system modelling language. The tool was evaluated and validated during a qualitative usability study with 17 engineers active in the Swedish automotive industry. Key findings are that searching is used to learn about a system, whereas filtering is used to narrow down a set of candidate elements of the system design. Engineers request further support in narrowing down a set of candidate elements and in checking that an allocation is correct.

Area 22 - Methodologies, Processes and Platforms

Posters
Paper Nr: 17
Title:

Towards Flexibility in Business Processes by Mining Process Patterns and Process Instances

Authors:

Andreas Bögl, Christine Natschläger and Verena Geist

Abstract: The possibility to react to unexpected situations in business process execution is restricted since all possible process flows must be specified at design-time. Thus, there is need for a flexible approach that reflects the way in which human actors would handle discrepancies between real-life activities and their representation in business process definitions. In this paper, we propose a novel approach that supports dynamic business processes and is based on a framework comprising a process pattern library with domain-specific patterns and execution logs for mining related process instances. Given a running business process and an unexpected situation, the proposed approach provides a largely automatic adaptation of the business process by replacing failed activities with fitting process alternatives identified by exploring existing process knowledge. The feasibility of the approach is demonstrated by applying the main steps to a business scenario taken from the industry domain.

Paper Nr: 21
Title:

Deriving Software Design Models from a Set of Business Processes

Authors:

Estrela F. Cruz, Ricardo J. Machado and Maribel Y. Santos

Abstract: Requirements elicitation is a crucial activity and one of the first steps in software development process. A popular way to capture and describe requirements is through UML use case models. Transforming requirement specifications into software design models is a complex and error prone software development activity. Software design usually involves several models, each one representing a different perspective. One of those perspectives is the data perspective which can be modeled using a data model. Although of the importance of this model, few works has been done to derive a data model from use case model. The 4SRS (4-Step Rule Set) method generates a logical architecture of a software-based system, based on a use case model. This paper proposes an approach to adapt and extend the 4SRS method in order to generate a data model supporting the generated logical architecture and the elicited requirements based in a set of business process models.

Area 23 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 25
Title:

SCDML: A Language for Conceptual Data Modeling in Model-based Systems Engineering

Authors:

Christian Hennig, Tobias Hoppe, Harald Eisenmann, Alexander Viehl and Oliver Bringmann

Abstract: This paper presents the design and usage of a language for Conceptual Data Modeling in Model-based Systems Engineering. Based on an existing analysis of presently employed data modeling languages, a new conceptual data modeling language is defined that brings together characteristic features from software engineering languages, features from languages classically employed for knowledge engineering, as well as entirely newly developed functional aspects. This language has been applied to model a spacecraft as an example, demonstrating its utility for developing complex, multidisciplinary systems in the scope of Modelbased Space Systems Engineering.

Area 24 - Methodologies, Processes and Platforms

Posters
Paper Nr: 26
Title:

A Methodology for Deriving Conceptual Data Models from Systems Engineering Artefacts

Authors:

Christian Hennig, Harald Eisenmann, Alexander Viehl and Oliver Bringmann

Abstract: This paper presents a novel methodology for deriving Conceptual Data Models in the scope of Model-based Systems Engineering. Based on an assessment of currently employed methodologies, substantial limitations of the state of the art are identified. Consequently, a new methodology, overcoming present shortcomings, is elaborated, containing detailed and prescriptive guidelines for deriving conceptual data models used for representing engineering data in a multi-disciplinary design process. For highlighting the applicability and benefits of the approach, the derivation of a semantically strong conceptual data model in the context of Model-based Space Systems Engineering is presented as a case study.

Area 25 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 31
Title:

Towards Distributed Ecore Models

Authors:

Jesús M. Perera Aracil and Diego Sevilla Ruiz

Abstract: Models are the cornerstone of Model-Driven Engineering (MDE). Their size is constantly growing, becoming one of the main problems when it comes to manipulating them, via model-to-model transformations, model-to- text transformations or simply parsing them. In this paper we propose a way of distributing Ecore models representing them as JSON and URLs as identifiers, since HTTP is one of the most successful distributed protocols ever created. An implementation of distributed Ecore models using a RESTful-like service is also presented and and is publicly available.

Paper Nr: 38
Title:

A MOF-based Social Web Services Description Metamodel

Authors:

Amel Benna, Zakaria Maamar and Mohamed Ahmed Nacer

Abstract: To promote and support the development and use of social Web services by the IT community on the Web, both social Web service-based applications and their support platforms should evolve independently from each other while sharing a common model that represents the characteristics of these social Web services. To achieve this duality, this paper proposes a model-driven approach. First, the approach identifies a social Web service's properties. Then a Meta-Object-Facility (MOF)-based social Web services description metamodel is developed. Finally, a prototype illustrates how the MOF-based metamodel is used.

Paper Nr: 39
Title:

Change Rule Execution Scheduling in Incremental Roundtrip Engineering Chain: From Model-to-Code and Back

Authors:

Van Cam Pham, Ansgar Radermacher, Sébastien Gérard and Florian Noyrit

Abstract: Model driven engineering allows many stakeholders to contribute their expertise to the system description. Incremental model transformations (IMT) are used to synchronize different artifacts contributed by the stakeholders. IMTs detect changes on the source model and execute change rules to propagate updates to the target model. However, the execution of change rules is not straightforward. A rule is only correctly executed if its precondition is satisfied at execution time. The precondition checks the availability of certain source and target elements involved in the rule. If a rule is executed at the time the involved elements are not appeared in the source and target models, either the execution is blocked or stopped. Therefore, the produced target model becomes incorrect. This paper presents two approaches to the scheduling of change rule execution in incremental model transformations. These approaches are also applied to the case of models and code synchronization and implemented in a tool named IncRoundtrip that transforms and generates code for distributed systems. We also compare the runtime execution performance of different incremental approaches with batch transformation and evaluate their correctness.

Paper Nr: 41
Title:

Comparing ConDec to CMMN - Towards a Common Language for Flexible Processes

Authors:

Renata M. de Carvalho, Hafedh Mili, Javier Gonzalez-Huerta, Anis Boubaker and Abderrahmane Leshob

Abstract: Flexible processes emerged to provide flexibility to business process execution. A flexible process is not static and can have several different executions, that is influenced by the current situation. In this context, the decision-making is placed in the hands of any knowledge worker during the execution, who decides which tasks and in which order they will be executed. Two approaches for flexible processes are discussed in this paper: case management and declarative processes. In particular we use the CMMN standard and the ConDec language for the two approaches, respectively. We compare them based on scope, model representation, formal semantics, and limitations. Our goal is to present commonalities and differences between the languages in order to identify potential extensions to make them more complete to attain more flexible process examples.

Area 26 - Applications and Software Development

Posters
Paper Nr: 44
Title:

Design of a Simulation Framework for Model-based Learning

Authors:

Sarah Zribi, Antonello Calabrò, Francesca Lonetti, Eda Marchetti, Tom Jorquera and Jean-Pierre Lorré

Abstract: In model-driven learning, simulation of Business Process is a key step for improving the learners's skills and enhancing teaching performance. In this paper, we provide the architectural design and the main functionalities of a model-based learning simulation framework. The main objectives of the proposed framework are: i) enable user-friendly learning simulation with a strong support for collaboration and social interactions; ii) provide a process-driven learning environment that allows emulation of the learner behavior when no learners are available to be involved on the simulation; iii) include event-based monitoring aiming at providing feedbacks for the learner assessment.

Paper Nr: 52
Title:

Exchanging Solutions for Information Systems Development using a Model Pattern Perspective - Diagram Templates in the Context of the Mdarte Collaborative Evolution Process

Authors:

Rodrigo Salvador Monteiro, Geraldo Zimbrão and Jano Moreira de Souza

Abstract: Information Systems Development faces many recurrent issues that must be addressed in every project. A lot of common requirements and features repeatedly appear on different projects challenging the development team. Exchanging solutions and the expertise gained over the evaluation of such solutions among projects can prevent the development teams from reinventing the wheel. The MDArte framework has been used to develop information systems through the Model Driven Architecture approach, automating the generation from models reaching around 80% of the application code. Most important is that the MDArte framework turned out to be a common platform between the adherent projects used to share new solutions and features. This paper focus on recurrent issues present at the modeling phase. We applied the concept of Model Patterns in order to provide diagram templates. A set of diagram templates were designed, implemented and evaluated by a volunteer project. The feedback was extremely positive and the proposed approach proves to be very promising. This level of collaboration between different projects on one hand accelerates the development and on the other hand prevents from neglecting important issues on information systems development.

Area 27 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 56
Title:

Multi-level Dynamic Instantiation for Resolving Node-edge Dichotomy

Authors:

Zoltan Theisz and Gergely Mezei

Abstract: The core idea of metamodel-based model construction is well established. However, there are different meta-modeling approaches relying on various modeling structures and instantiation procedures. Although, in general, these approaches offer similar features, they are sometimes incompatible with each other. Therefore, a precise abstract definition of instantiation is needed. The paper describes an abstract modeling framework, which is easily customizable in order to adapt it to different multi-level modeling techniques. The framework consists of an abstract modeling structure, basic built-in constructs, and a dynamic instantiation procedure. The paper demonstrate the flexibility of the approach by a specific bootstrap that is explicitly designed for the rebalancing of the node-edge antagonism, which is mostly the origin of many reification patterns applied in current meta-model designs. Although the proposed solution to the node-edge dichotomy is only an example of our multi-level meta-modeling approach, it is per se a valuable achievement showing that it can be done in a more elegant manner than it is usually expressed in other state-of-the art modeling frameworks.

Area 28 - Applications and Software Development

Posters
Paper Nr: 57
Title:

Virtual Worlds on Demand? Model-Driven Development of JavaScript-based Virtual World UI Components for Mobile Apps

Authors:

Matthias Stürner and Philipp Brune

Abstract: Virtual worlds and avatar-based interactive computer games are a hype among consumers and researchers for many years now. In recent years, such games on mobile devices also became increasingly important. However, most virtual worlds require the use of proprietary clients and authoring environments and lack portability, which limits their usefulness for targeting wider audiences like e.g. in consumer marketing or sales. Using mobile devices and client-side web technologies like i.e. JavaScript in combination with a more automatic generation of customer-specific virtual worlds could help to overcome these limitations. Here, model-driven software development (MDD) provides a promising approach for automating the creation of user interface (UI) components for games on mobile devices. Therefore, in this paper an approach is proposed for the model-driven generation of UI components for virtual worlds using JavaScript and the upcoming Famo.us framework. The feasibilty of the approach is evaluated by implementing a proof-of-concept scenario.

Area 29 - Methodologies, Processes and Platforms

Posters
Paper Nr: 58
Title:

A Categorization of GSN-based Safety Cases and Patterns

Authors:

Yaping Luo, Zhuoao Li and Mark van den Brand

Abstract: Recently modeling techniques are introduced to support safety assessment. Goal Structural Notation is one of these modeling techniques, which can be used to facilitate the development of safety argumentation and create reusable safety argumentation models. Consequently, GSN-based safety cases are widely used to demonstrate the safety of systems in safety-critical domains. Due to the amount of manual work, constructing a safety case is usually time-consuming. Moreover, the re-usability of GSN-based safety cases is limited. To address this, safety case patterns are introduced to support safety case reuse. As more and more GSN-based safety cases and patterns are designed with different goals in different contexts, it becomes hard to identify a reusable safety case or pattern. In this paper, we carried out a study on the categorization of existing GSN-based safety cases and patterns. As a result, a number of high cited publications are selected and studied. Finally a categorization of GSN-based safety cases is proposed. A clear categorization of GSN-based safety cases can be used to identify similar safety cases or patterns and facilitate safety case reuse.

Paper Nr: 60
Title:

EXE-SPEM: Towards Cloud-based Executable Software Process Models

Authors:

Sami Alajrami, Barbara Gallina and Alexander Romanovsky

Abstract: Executing software processes in the cloud can bring several benefits to software development. In this paper, we discuss the benefits and considerations of cloud-based software processes. EXE-SPEM is our extension of the Software and Systems Process Engineering (SPEM2.0) Meta-model to support creating cloud-based executable software process models. Since SPEM2.0 is a visual modelling language, we introduce an XML notation meta-model and mapping rules from EXE-SPEM to this notation which can be executed in a workflow engine. We demonstrate our approach by modelling an example software process using EXE-SPEM and mapping it to the XML notation.

Area 30 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 62
Title:

Umple as a Component-based Language for the Development of Real-time and Embedded Applications

Authors:

Mahmoud Husseini Orabi, Ahmed Husseini Orabi and Timothy Lethbridge

Abstract: Component-based development enforces separation of concern to improve reusability and maintainability. In this paper, we show how we extended Umple (http://try.umple.org) to support component-based development. The development of components, ports, and connectors is enabled using easy-to-comprehend keywords. Development is supported in both textual and visual representations. The design pattern followed in our implementation is the active object pattern. We show a comparison between Umple and other modelling tools. We show that Umple has a set of component features comparable to commercial modelling tools, but is the most complete, particularly with regard to code generation, among the open source tools.

Paper Nr: 67
Title:

An EMF-like UML Generator for C++

Authors:

Sven Jäger, Ralph Maschotta, Tino Jungebloud, Alexander Wichmann and Armin Zimmermann

Abstract: Model-driven architecture is a well-known approach for the development of complex software systems. The most famous tool chain is provided by Eclipse with the tools of the Eclipse modeling project. Like Eclipse itself, these tools are based on Java. However, there are numerous legacy software packages written in C++, which often use only an implicit meta-model. A real C++ implementation of this meta-model would be necessary instead to be used at run time. This paper presents a generator for C++ to create the classes, meta-model packages, and factories to realize modeling, transformation, validation, and comparison of UML models. It gives an overview of its workflow and major challenges. Moreover, a comparison between Java and C++ implementations is given, considering different benchmarks.

Paper Nr: 70
Title:

Comparative Analysis of Workbenches to Support DSMLs: Discussion with Non-Trivial Model-Driven Development Needs

Authors:

André Ribeiro, Luís de Sousa and Alberto Rodrigues da Silva

Abstract: The development and use of Domain Specific Languages emerged as a way to cope with complex problems using concepts closer to the problem domain. By leveraging the principles proposed by Model-Driven Development (MDD), like the separation of concerns and the use of model transformations, this approach became popular and caused the emergence of a variety of languages, known as Domain Specific Modeling Languages (DSMLs). Moreover, the use of DSMLs with graphical notations abstracts even more the problem domain, either by using extensions of UML or directly using metamodeling languages. The definition and use of DSMLs is only possible through specific tools, known as languages workbenches. This paper discusses the analysis and comparison of three of these tools (namely Papyrus, Enterprise Architect and Sirius) that were used to create the XIS-Mobile language, a non-trivial DSML defined as a UML profile for modeling mobile applications in a platform-independent way. These tools were evaluated considering a set of key criteria (namely learnability, usability, graphical completeness, validation support, transformation support, evolvability and interoperability) which show their suitability to develop non-trivial languages.

Area 31 - Applications and Software Development

Posters
Paper Nr: 76
Title:

Comparing System- and Test Model with Integrated Software-based Signal Simulation

Authors:

Andreas Kurtz, Bernhard Bauer and Marcel Koeberl

Abstract: Test automation in distributed systems requires new methods in signal simulation for the stimulation of the distributed system. Increasing complexity of electric electronic (E/E) systems enhances the testing-effort. The main challenge is reducing the time consuming manual stimulation in consideration of improving the quality of testing. Currently used systems for test automation with a software-based approach have to be adapted to each hardware and software version of the system to be tested. The approach represented shows a new approach through the integration of a simulation service in the AUTOSAR software architecture. By integrating a generic software-based simulation module with an interaction point at the basic software driver layer, the execution of tests can be automated and improved under consideration of adaptivity and reproducibility.

Area 32 - Methodologies, Processes and Platforms

Posters
Paper Nr: 83
Title:

Modeling Requirements Should be Language Agnostic! - Example of a Formal Definition of Simple Behavioral Decomposition Models

Authors:

Gurvan Le Guernic

Abstract: This paper argues in favor of expressing modeling requirements in a modeling language agnostic way, at least whenever those requirements are part of a contracting relationship between some of the stakeholders. Contracting authorities may require from contractors specific design models in order to perform early design (functional, safety, security, etc.) analyses. However, in order to allow contractors to use the compatible modeling language of their choice with the compatible modeling guidelines of their choice, the formal definition of the model requirements must be independent from any concrete modeling language or guideline. This paper introduces, based on the example of Behavioral Decomposition Models, an approach to express such agnostic requirements. This is achieved by defining a semantic domain, some correctness constraints and, later, the necessary mappings between them and the desired concrete syntaxes.

Area 33 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 85
Title:

Exploring the Potential of Global Types for Adding a Choreography Perspective to the jABC Framework

Authors:

Paola Giannini, Anna-Lena Lamprecht and Tiziana Margaria

Abstract: We discuss how global types, aka multiparty session types, provide a complementary perspective on workflow models within the jABC modeling framework. On a reference example from the Semantic Web Services Challenge we show how the service orchestrations of jABC workflow applications can be expressed as service choreographies based on global types. Roles, identified with sets of logically related Service-Independent Building Blocks (SIBs), bridge between the two ways of looking at the behavior of systems. We compare the degree of declarativity and robustness in the face of changes of the reference example modeled with the jABC framework with as a global types specification.

Paper Nr: 86
Title:

Modelling CAD Models - Method for the Model Driven Design of CAD Models for Deep Drawing Tools

Authors:

Robert Scheffler, Sergej Koch, Gregor Wrobel, Matthias Pleßow, Christian Buse and Bernd-Arno Behrens

Abstract: Designing a fully parametric CAD model of a sheet forming tool in a 3D CAD system expends temporal and financial effort and thus engineers shy away from it. The Institute of Forming Technology and Machines (IFUM) and the Society for the Advancement of Applied Computer Science (GFaI) are currently developing a new method for the model driven design of deep drawing tools. The core of this method is a graphical modelling language for the domain of deep drawing tools. Meta models of these tools allow the generation of models which in turn can be transformed to parametric CAD models and completed by geometric modelling. The new method makes the modelling of parametric relations and dependencies easier and less error-prone.

Paper Nr: 87
Title:

ReIOS: Reflective Architecting in the Internet of Objects

Authors:

Marina Mongiello, Gennaro Boggia and Eugenio Di Sciascio

Abstract: Self-adaptive systems are modern applications in which the running software system should be able to react on its own, by dynamically adapting its behavior, for sustaining a required set of qualities of service, and dynamic changes in the context or in user requirements. They are typically involved in Future Internet development such as the Internet of Things where interoperability, flexibility, and adaptability are key requirements. Convergence of contents, services, things and networks seems to be the cornerstone to fullfil these requirements. We propose a reflective approach to provide a common abstraction for automating the deployment of component based applications in the Internet of Things environment. The proposed framework allows the design of heterogeneous, distributed, and adaptive applications built on the component based software engineering paradigm. The framework considers a metamodel instantiated in a Rest middleware properly modified for allowing different implementations by using reflective design patterns. We are currently working to refine the framework metamodel and to validate it in several implementation domains.

Area 34 - Applications and Software Development

Posters
Paper Nr: 88
Title:

Model-driven Engineering Tool Comparison for Architectures within Heterogenic Systems for Electric Vehicle

Authors:

Sebastian Apel, Marianne Mauch and Volkmar Schau

Abstract: System landscapes within logistical scenarios is highly heterogenic. Adding specific mechanisms, e.g. to support planing, monitoring and analyses for fully electrical powered vehicles, could become a mess or at least a challenge. While our project Smart City Logistic (SCL) is trying to manage this extension for multiple logistic scenarios, other projects want to do comparable system extensions as well. The following approach tries to evaluate how model-driven engineering (MDE) combined with generative frameworks can support the transfer from platform independent models to deployable solutions within the logistical domain. This paper compares specific MDE tools which can be used to support such a framework.

Area 35 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 95
Title:

Towards a Hybrid Semi-automatic Technique for Metamodel Matching

Authors:

Lamine Lafi, Jamel Feki and Slimane Hammoudi

Abstract: During the last two decades the theory of model transformation has been extensively studied and subject of many research. So far, several transformation languages have been developed and implemented. Recently, a metamodel matching technique has been proposed in order to find mapping models that support the deduction of transformations definitions. The model matching aims at searching semantic similarity between models elements, and therefore, facilitating semi-automatic mapping generation. However, current model matching techniques mostly focus on some comparison criteria (i.e., pre-matching effort, input model, output model, quality measures values) while ignore others; in addition these techniques are used in isolation, so that their advantages and commons are not exploited. In this paper, we tackle these issues by proposing a new technique relying on combination of metamodels matching techniques. To reach our goal, schema and ontology matching techniques can be adapted to develop a hybrid technique for metamodel matching. This technique will produce better matching results increasing the mappings quality.

Paper Nr: 98
Title:

An Approach to Class Diagrams Verification According to SOLID Design Principles

Authors:

Elena Chebanyuk and Krassimir Markov

Abstract: An approach, verifying class diagram correspondence to SOLID Design Principles, is proposed in this paper. SOLID is an acronym, encapsulating the five class diagram design principles namely: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation and Dependency Inversion. To check whether a class diagram meets to SOLID, its analytical representation is analyzed by means of predicate expressions. For every SOLID design principle corresponded predicate expressions are proposed. Analytical representation describes interaction of class diagram constituents, namely classes and interfaces, in set-theory terms. Also criteria for estimation of obtained results are formulated. Example of class diagram verification according to the suggested verification approach is also represented in this paper. The advantages of the proposed verification approach implementing to improve the quality of different software development lifecycle processes are outlined in the conclusions.