MODELSWARD 2017 Abstracts


Area 1 - Applications and Software Development

Full Papers
Paper Nr: 32
Title:

Model-Driven Performance Evaluation and Formal Verification for Multi-level Embedded System Design

Authors:

Daniela Genius, Letitia W. Li and Ludovic Apvrille

Abstract: The design methodology of an embedded system should start with a system-level partitioning dividing functions into hardware and software. However, since this partitioning decision is taken at a high level of abstraction, we propose regularly validating the selected partitioning during software development. The paper introduces a new model-based engineering process with a supporting toolkit, first performing system-level partitioning, and then assessing the partitioning choices thus obtained at different levels of abstraction during software design. This assessment shall in particular validate the assumptions made on system-level (e.g. on cache miss rates) that cannot be precisely determined without low-level hardware model. High-level partitioning simulations/verification rely on custom model-checkers and abstract models of software and hardware, while low-level prototyping simulations rely on automatically generated C-POSIX software code executing on a cycle-precise virtual prototyping platform. An automotive case study on an automatic braking application illustrates our complete approach.

Short Papers
Paper Nr: 12
Title:

Towards an Automated Synthesis of a Real-time Scheduling for Cyber-physical Multi-core Systems

Authors:

Johannes Geismann, Uwe Pohlmann and David Schmelter

Abstract: Modern Cyber-physical Systems are executed in physical environments and distributed over several Electronic Control Units using multiple cores for execution. These systems perform safety-critical tasks and, therefore, have to fulfill hard real-time requirements. To face these requirements systematically, system engineers develop these systems model-driven and prove the fulfillment of these requirements via model checking. It is important to ensure that the runtime scheduling does not violate the verified requirements by neglecting the model checking assumptions. Currently, there is a gap in the process for model-driven approaches to derive a feasible runtime scheduling that respects these assumptions. In this paper, we present an approach for a semi-automatic synthesis of behavioral models into a deterministic scheduling that respects real-time requirements at runtime. We evaluate our approach using an example of a distributed automotive system with hard real-time requirements specified with the MechatronicUML method.

Paper Nr: 43
Title:

Modelling Behavioural Requirements and Alignment with Verification in the Embedded Industry

Authors:

Grischa Liebel, Anthony Anjorin, Eric Knauss, Florian Lorber and Matthias Tichy

Abstract: Formalising requirements has the potential to solve problems arising from deficiencies in natural language descriptions. While behavioural requirements are rarely described formally in industry, increasing complexity and new safety standards have renewed the interest in formal specifications. The goal of this paper is to explore how behavioural requirements for embedded systems can be formalised and aligned with verification tasks. Over the course of a 2.5-year project with industry, we modelled existing requirements from a safety-critical automotive software function in several iterations. Taking practical limitations and stakeholder preferences into account, we explored the use of models on different abstraction levels. The final model was used to generate test cases and was evaluated in three interviews with relevant industry practitioners. We conclude that models on a high level of abstraction are most suitable for industrial requirements engineering, especially when they need to be interpreted by other stakeholders.

Paper Nr: 68
Title:

Security Requirements Verification for Existing Systems with Model Checking Technique and UML

Authors:

Saeko Matsuura, Shinpei Ogata and Yoshitaka Aoki

Abstract: In software development, when making migration or specification changes to an existing system, it is important to verify that the new source code meets the original specifications. We propose an effective use of model checking techniques and a supporting tool that allows non-specialized developers to easily verify specification conformance. In this study, we verify security requirements for an ongoing learning management system that has insufficient specification documentation and discuss the applications and challenges for developing the model checking technology.

Paper Nr: 79
Title:

Automated Dynamic Formation of Component Ensembles - Taking Advantage of Component Cooperation Locality

Authors:

Filip Krijt, Zbynek Jiracek, Tomas Bures, Petr Hnetynka and Frantisek Plasil

Abstract: Smart cyber-physical systems (sCPS) is a growing research field focused on scenarios where a set of autonomous software-hardware entities (components) is cooperating via network communication to achieve a type of swarm or cloud intelligence. Typically the components’ cooperation is designed at a low level of abstraction and their behavior validated via simulations. As a remedy, a declarative language capable of specifying high-level component ensembles has been proposed in recent work. By capturing component functionality and the cooperation constraints, a specification serves both for generating platform-specific implementation and as a model@run.time to support self-adaption via dynamic formation of ensembles. However, for a particular specification, multiple possible architectural configurations exist with various impact on the system. Given their typically large number, we select the best one via an SMT solver. In this paper, we show that scalability of such approach can be supported by exploiting the effect of locality in component cooperation and by hoisting specific domain knowledge to the level of architecture.

Area 2 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 76
Title:

XIS-Reverse: A Model-driven Reverse Engineering Approach for Legacy Information Systems

Authors:

André Reis and Alberto Rodrigues da Silva

Abstract: Due to the development of new technologies companies face high costs managing and maintaining their legacy applications, thus upgrading those systems became a complex challenge. This paper describes a model-driven reverse engineering approach that aims to support the mentioned challenge. This approach takes as input the legacy relational database schema, but also user preferences to better guide the reverse engineering process. From these artefacts it is possible to extract models of the legacy application through model-to-model transformations based on a set of well defined rules and heuristics. The main contributions of this proposal (compared with the state of the art) are the semi-automatic identification of generalizations and aggregations and the possibility to automatically extract default values to enrich the produced models. The paper also includes an evaluation and a discussion of the proposal based on a simple case study and a real-world application.

Paper Nr: 84
Title:

Model Driven Implementation of Security Management Process

Authors:

Bruno A. Mozzaquatro, Ricardo Jardim-Gonçalves and Carlos Agostinho

Abstract: Services composition involves many time and effort to describe high-level requirements of the business process. To this purpose, the Model Driven Service Engineering Architecture (MDSEA) is a methodology to distinguish the business view and technical point of view in products and services and to agilize the software development. Such capabilities demand more effective process applied to specify, evaluate, communicate and design the system as well as system functionalities and security issues. Security aspects are critical when it involves privacy of data exchange of devices. In this context, the definition of security artifacts during the design of a business process consumes time of system funcionalities development. This paper proposes an implementation of a security management process using the methodology MDSEA as support to promote model transformations from business model to specific artifacts and configurations. This support enables to enrich a solid business model with technical details by specialists.

Paper Nr: 85
Title:

Process Development for the Liquid-sensing Enterprise

Authors:

Carlos Agostinho, José Ferreira, Joaquim Pereira, Catarina Lucena and Klaus Fischer

Abstract: Servitization and product-based services are used to support the integration of products and services with customers, enabling companies to maintain a competitive advantage in their markets. However, in order to achieve these capabilities is necessary to have flexible processes and services. The enterprise needs to become self and context aware to meet these new challenges, and with the Internet-of-Things development, resources can be shared across companies to reduce costs. Enterprise integration is an essential component of enterprise and service engineering but traditional modelling techniques need to evolve and become more dynamic, separating concerns but at the same time promoting knowledge reuse. This paper contributes to a more flexible environment for information systems and service development, proposing a model-driven framework for dynamic process development in the enterprise of the future. It applies the concept of the liquid-sensing enterprise following the Osmosis processes paradigm, supporting the enterprises to model and design their processes at business and technical level. With the support of a modelling toolbox the enterprises are able to parameterize their processes and accelerate the advancement from the design phase into services execution phase.

Short Papers
Paper Nr: 34
Title:

Model Execution and Debugging - A Process to Leverage Existing Tools

Authors:

Faiez Zalila, Eric Jenn and Marc Pantel

Abstract: Model checking is an effective technique for the verification of critical systems. However, it relies on behavioral models which are costly to write and maintain. Thus, those models shall be validated and debugged thoroughly, and simulation, i.e. model execution, can be used for that purpose. To reduce the development costs of simulators and ensure their behavioral consistency with model verifiers, we advocate the reuse of parts of the model verification tool-chain to implement them. To support this claim, this paper proposes a method illustrated with a realistic case study applied to FIACRE behavioral models. The approach relies on the creation and exploitation of relations between models representing the information required by the user on the one hand, and information produced by the tools, on the other hand.

Paper Nr: 42
Title:

A UML Profile for the Specification of System Architecture Variants Supporting Design Space Exploration and Optimization

Authors:

Alexander Wichmann, Ralph Maschotta, Francesco Bedini, Sven Jäger and Armin Zimmermann

Abstract: The optimization of complex systems as well as other design methods require a description of the system parameters, or the design space. Explicit encoding of all possible variants is practically impossible, thus an implicit method is needed. While this is easy for purely numerical parameters and a fixed number of them as usually assumed in direct or indirect optimization, it is quite hard for systems in which the architecture and thus the structure of the parameters themselves can be varied. This paper introduces an approach to specify system architecture variants in a concise way and proposes a UML profile for this task. Standard UML meta model elements are used for the description of variant-specific stereotypes. An example of a variant specification for a communication network model is presented.

Posters
Paper Nr: 20
Title:

Automating the Customization of Model-Driven Software Engineering Environments

Authors:

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

Abstract: This paper presents a strategy to facilitate the customization of MDSE software development environments, which aims at providing the software engineers who design, implement and maintain those environments with capacity to automate the generation of tools supporting new development processes. A generic conception for the design of software development environments based on the MDSE paradigm, called MDDE (Model-Driven Development Environment), has been defined as basis of the proposed strategy. In MDDE, the definition of the processes that determine the functionality of an environment as well as their options regarding interaction, supervision and control by the users are completely formulated as models. To support this capability, the MDDE reference model includes a meta-model that formalizes such models. A sample implementation called MDDE-MinMAST2 is presented for illustrative purposes.

Paper Nr: 52
Title:

Use of Architecture Description to Maintain Consistency in Agile Processes

Authors:

Aurélien Chichignoud, Florian Noyrit, Laurent Maillet-Contoz and François Terrier

Abstract: The development of highly complex products requires the maintenance of a huge set of inter-dependent documents, in various formats, developed concurrently according to agile methods. Unfortunately, no tool or methodology is available today to systematically maintain consistency between all these documents. Therefore, according to observations made in STMicroelectronics, when a document changes, stakeholders must manually propagate the changes to the impacted set of dependent documents. For various reasons, they may not well propagate the change, or even may not propagate it at all. Related documents thereby diverge more and more over time. This is a source of bugs that are difficult to identify and fix; potentially jeopardizing product reliability and quality. This paper proposes a methodology to help stakeholders to systematically maintain consistency between documents, based on the Architecture Description concept introduced by ISO42010. First, a model is defined to describe completely correspondences between Architecture Description Elements of documents. This model is designed to be independent of documents formats, selected system development lifecycle and the working methods of the industry. Second, these correspondences are analyzed in case of document modification in order to help stakeholders maintaining corpus consistency. A tool has been prototyped to evaluate the approach.

Paper Nr: 69
Title:

Towards Effective SysML Model Reuse

Authors:

Roy Mendieta, Jose Luis de la Vara, Juan Llorens and Jose María Álvarez-Rodríguez

Abstract: The Systems Modeling Language (SysML) is spreading very fast. Most modelling tool vendors support it and practitioners have adopted it for Systems Engineering. The number of SysML models is growing, increasing the need for and the potential benefit from platforms that allow a user to reuse the knowledge represented in the models. However, SysML model reuse remains challenging. Each tool has its own implementation of SysML, hindering reuse between tools. The search capabilities of most tools are also very limited and finding reusable models can be difficult. This paper presents our vision and initial work towards enabling an effective reuse of the knowledge contained in SysML models. The proposed solution is based on a universal information representation model called RSHP and on existing technology for indexing and retrieval. The solution has been used to index models of all SysML diagram types and preliminary validated with requirements diagrams. The results from the validation show that the solution has very high precision and recall. This makes us confident that the solution can be a suitable means for effective SysML model reuse.

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 2
Title:

Maintaining Workspace Consistency in Filtered Editing of Dynamically Evolving Model-driven Software Product Lines

Authors:

Felix Schwägerl and Bernhard Westfechtel

Abstract: Model-driven software product line engineering is complicated: In addition to defining a variability model, developers must deal with a multi-variant domain model. To reduce complexity, filtered editing, inspired by version control, was recently transferred to software product line engineering. On check-out, a single-variant model is derived based on a configuration of its features. On commit, the representatively applied change is scoped with the features to which it is relevant. The here considered dynamic editing model involves different kinds of evolution: The variability model and the domain model are edited concurrently. Features, which define the workspace contents or the scope of the change, may be introduced or deleted. Furthermore, the scope of a change may be revised until commit. The dynamism of this filtered editing model raises consistency problems concerning the evolving relationships between the variability model, the specified configuration, and the scope of the change. This paper formalizes these constraints and presents consistency-preserving algorithms for the workspace operations check-out, commit, as well as a new operation, migrate. This way, the evolution of model-driven software product lines is managed automatically, non-disruptively, and consistently.

Paper Nr: 11
Title:

Deterministic Executable Models Verified Efficiently at Runtime - An Architecture for Robotic and Embedded Systems

Authors:

Vladimir Estivill-Castro and René Hexel

Abstract: We show an architecture that enables runtime verification. Runtime verification focusses on the design of formal languages for the specification of properties that must hold during runtime. In this paper, we take matters one step further and describe a uniform modelling and development paradigm for software systems that can monitor the quality of software systems as they execute, set-up, tear-down and enforce quality behaviour on the fly. Our paradigm for modelling behaviour enables efficient execution, validation, simulation, and runtime-verification. The models are executable and efficient because they are compiled (not interpreted). Moreover, they can be developed using test-driven development, where tests are models derived from requirements. We illustrate the approach with case studies from robotics and embedded systems.

Paper Nr: 16
Title:

Optimizing Distributed Resource Allocation using Epistemic Game Theory: A Model-driven Engineering Approach

Authors:

Fazle Rabbi, Lars Michael Kristensen and Yngve Lamo

Abstract: Distributed systems modelling often involves a set of heterogeneous models where each model specifies a set of local constraints capturing a specific view of the system. In real life, distributed systems are often loosely connected and interdependencies are not defined into their software model. This limits the scope of optimization of distributed resources. In this paper, we merge heterogeneous models of distributed systems and articulate distributed resource constraints via inter-metamodel constraints. We apply model-driven engineering and use model transformation rules to construct an epistemic game theory model for the purpose of optimizing distributed resource allocation. Since the application of transformation rules normally do not guarantee the satisfaction of constraints when applied on a model, it requires a conformance checking which is an expensive operation. To overcome this problem, we introduce the concept of compliant rule and coordinate with other rules for efficient model transformation.

Paper Nr: 24
Title:

Flexible Specification of STEP Application Protocol Extensions and Automatic Derivation of Tool Capabilities

Authors:

Thorsten Koch, Jörg Holtmann and Timo Lindemann

Abstract: Original equipment manufacturers (OEMs) build mechatronic systems using components from several suppliers in industry sectors like automation. The suppliers provide geometrical information via the standardized exchange format STEP, such that the OEM is able to virtually layout the overall system. Beyond the geometrical information, the OEM needs additional technical information for his development tasks. For that reason, STEP provides an extension mechanism for extending and tailoring STEP to project-specific needs. However, extending STEP moreover requires extending several capabilities of all involved tools, causing high development effort. This effort prevents the project-specific utilization of the STEP extension mechanism and forces the organizations to use awkward workarounds. In order to cope with this problem, we present a model-driven approach enabling the flexible specification of STEP extensions and particularly the automatic derivation of the required further capabilities for two involved tools. We illustrate and evaluate the approach with an automation production system example.

Paper Nr: 25
Title:

Towards Sharable Application Ontologies for the Automatic Generation of UIs for Dialog based Linked Data Applications

Authors:

Michael Hitz, Thomas Kessel and Dennis Pfisterer

Abstract: The emerging Internet of Everything is a driving force for businesses to expose their processes as services to third parties to be integrated into their applications (e.g. the booking of a trip or requesting the quote for a complex product). To standardize the processes and related data, increasingly semantic web technologies are applied - leading to a shared conceptualization of the business domains and thus creating a linked data service ecosystem for domain-specific services. Although the communication on machine-level is standardized by using semantic web technologies, the integration of the user into the overall process is still a manual task: User Interfaces (UI) for collecting the input data for a process are built manually for multiple platforms and user groups. The claim of this paper is, that given a linked data service ecosystem, UIs can be modelled and automatically generated for integration into linked data applications. The paper presents an ontology-based, model-driven approach for modelling UI variants for automatically generating dialog-based applications, providing output understood by associated linked data services.

Paper Nr: 36
Title:

On the Evolution of Modeling Ecosystems: An Evaluation of Co-Evolution Approaches

Authors:

Juergen Etzlstorfer, Elisabeth Kapsammer and Wieland Schwinger

Abstract: In Model-Driven Engineering, several artifacts together form a so-called modeling ecosystem, comprising metamodels defining prevailing concepts of a domain and depending artifacts using these concepts. However, evolutionary pressure causes the need for changes in the metamodel, necessitating all artifacts in the modeling ecosystem to migrate to again conform to the evolved version of the metamodel, i.e., they have to co-evolve accordingly. Several approaches for the co-evolution of artifacts have been proposed, however, they differ substantially from each other and, thus, an in-depth investigation of these approaches is needed to allow for a systematic comparison. Therefore, the contribution of this paper is a dedicated evaluation framework for coevolution approaches focusing on aspects relevant in the context of modeling ecosystems, and its application to a representative set of recent approaches. Based on this evaluation lessons learned as well as future research lines are presented.

Paper Nr: 37
Title:

An Exploration of the ‘It’ in ‘It Depends’: Generative versus Interpretive Model-Driven Development

Authors:

Michiel Overeem and Slinger Jansen

Abstract: Software producing organizations are increasingly using model driven development platforms to improve software quality and developer productivity. Software architects, however, need to decide whether the platform generates code (that might be compiled) or if the model is immediately interpreted by an interpreter embedded in the application. Presently, there is no clear guidance that enables architects to decide for code generation, interpretation, or a hybrid approach. Although the approaches are functionally equivalent, they have different quality characteristics. An exploration is done on the quality characteristics of code generation versus interpretation as a model execution approach. A literature study is done to gather quantitative data on the quality characteristics of the two model execution approaches. The results of this study are matched with observations made during a case study. With the resulting support method architects of model driven development platforms can avoid costly wrong choices in the development of a model driven development platform.

Paper Nr: 38
Title:

Testing Environment Emulation - A Model-based Approach

Authors:

Jian Liu, John Grundy, Mohamed Abdelrazek and Iman Avazpour

Abstract: Modern enterprise software systems often need to interact with a large number of distributed and heterogeneous systems. As a result, integration testing has become a critical step in their software development lifecycle. Service virtualization is an emerging technique for creating testing environments with realistic executable models of server side production-like behaviours. However, building models in existing service virtualization approaches is very challenging, requiring either significant human effort or the availability of interactive tracing records. In this paper, we present a domain-specific modeling approach to generate complex, virtualized testing environments. Our approach allows domain experts to use a suite of domain-specific visual modeling languages to model key interface layers of applications at a high level of abstraction. These layered models are then transformed into a testing runtime environment for application integration testing. We have conducted a technical comparison with two other existing approaches and also carried out a user study. The user study demonstrated the acceptance of our new testing environment emulation approach from software testing experts and developers.

Paper Nr: 39
Title:

SMART REIFIER: Model-Driven Development of Service-Oriented SCADA Applications from Models of Sensor and Actuator Networks

Authors:

Jérôme Rocheteau, Clémentine Geslin and Margaux Bosshardt

Abstract: This paper aims at presenting SMART REIFIER a tool for designing networks of sensors and actuators and for generating a set of web services for supervisory control and data acquisition. Such a code generation is achieved by the means of model-driven engineering: a specific metamodel for sensor and actuator networks is designed as well as a model-to-model mapping into a web service meta-model that enables source code generation of JEE applications.

Paper Nr: 41
Title:

CloudTL: A New Transformation Language based on Big Data Tools and the Cloud

Authors:

Jesús M. Perera Aracil and Diego Sevilla Ruiz

Abstract: Model Driven Engineering (MDE) faces new challenges as models increase in size. These so called Very Large Models (VLMs) introduce new challenges, as their size and complexity cause transformation languages to have long execution times or even not being able to handle them due to memory issues. A new approach should be proposed to solve these challenges, such as automatic parallelization or making use of big data technologies, all of which should be transparent to the transformation developer. In this paper we present CloudTL, a new transformation language whose engine is based on big data tools to deal with VLMs in an efficient and scalable way, benchmarking it against the de facto standard, ATL.

Paper Nr: 44
Title:

Language Architecture: An Architecture Language for Model-Driven Engineering

Authors:

Niels Brouwers, Marc Hamilton, Ivan Kurtev and Yaping Luo

Abstract: The increasing number of languages used to engineer complex systems causes challenges to the development and maintenance processes of these languages. In this paper, we reflect on our experience in developing real life complex cyber-physical systems by using MDE techniques and DSLs. Firstly, we discuss a number of industrial challenges in the modeling software engineering domain. To address these challenges, we propose the concept of language architecture as an organizational principle for designing, reusing and maintaining DSLs and their infrastructure. Based on this, a metamodel for a DSL is designed and a tool support (LanArchi) is developed. Finally the possible future directions are given.

Paper Nr: 46
Title:

A Domain-aware Framework for Integrated Model-based System Analysis and Design

Authors:

Adrian Rumpold, Reinhard Pröll and Bernhard Bauer

Abstract: The increasing complexity of modern embedded systems demands advanced design and development methods. Incremental evolution of model-based engineering practice has led to heterogeneous tool environments without proper integration and exchange of design artifacts. These problems are especially prevalent in tightly regulated domains, where an independent assessment is required for newly developed products, e.g. in automotive or aviation systems. To address these shortcomings of current engineering practice, we propose a holistic model-based approach for the seamless design and development of an integrated system model. We describe an embedding of a variety of domain-specific modeling languages into a common general-purpose modeling language, in order to facilitate the integration between heterogeneous design artifacts. Based on this conceptual modeling approach, we introduce a framework for automated model-based analysis of integrated system models. A case study demonstrates the suitability of this modeling and analysis approach for the design of a safety-critical embedded system, a hypothetical gas heating burner.

Paper Nr: 54
Title:

The Power of a Model-Driven Approach to Handle Evolving Data Warehouse Requirements

Authors:

Said Taktak, Saleh Alshomrani, Jamel Feki and Gilles Zurfluh

Abstract: The Data Warehouse (DW) is characterized by complex architecture, specific modeling and design approaches. It integrates data issued from operational data sources in order to meet decision-makers’ needs by providing answers for OLAP queries (On-Line Analytical Processing). In practice, both data source models and decision-makers’ analytical requirements evolve over time and, therefore, lead to changes in the DW multidimensional model. In this evolving context, we have developed the DWE (Data Warehouse Evolution) framework. DWE automatically propagates the changes of the data source data-model on the DW data-model. This paper proposes a model-driven approach for extending DWE in order to consider a further related evolutionary aspect: The evolution of decision-makers’ needs. It deals with the propagation of these evolutions on the DW multidimensional model. This approach relies on a classification of evolution scenarios and a set of transformation rules for the identification of evolution operations to apply on the DW.

Paper Nr: 74
Title:

Distributing Scenario-based Models: A Replicate-and-Project Approach

Authors:

Shlomi Steinberg, Joel Greenyer, Daniel Gritzner, David Harel, Guy Katz and Assaf Marron

Abstract: In recent years, scenario-based modeling has been proposed to help mitigate some of the underlying difficulties in modeling complex reactive systems, by allowing modelers to specify system behavior in a way that is intuitive and directly executable. This modeling approach simplifies the specification of systems that include events occurring in distinct system components. However, when these system components are physically distributed, executing the scenario-based model requires inter-component coordination that may negatively affect system performance or robustness. We describe a technique that aims to reduce the amount of joint event-selection decisions that require coordination and synchronization among distributed system components. The technique calls for replicating the entire scenario-based executable specification in each of the components, and then transforming it in a component-specific manner that induces the required differences in execution while reducing synchronization requirements. In addition to advantages in streamlining design and improving performance, our approach captures the fact that in certain ``smart' distributed systems it is often required that components know what rules govern the behavior of other components. Our evaluation of the technique shows promising results.

Paper Nr: 81
Title:

Complete Code Generation from UML State Machine

Authors:

Van Cam Pham, Ansgar Radermacher, Sébastien Gérard and Shuai Li

Abstract: An event-driven architecture is a useful way to design and implement complex systems. The UML State Machine and its visualizations are a powerful means to the modeling of the logical behavior of such an architecture. In Model Driven Engineering, executable code can be automatically generated from state machines. However, existing generation approaches and tools from UML State Machines are still limited to simple cases, especially when considering concurrency and pseudo states such as history, junction, and event types. This paper provides a pattern and tool for complete and efficient code generation approach from UML State Machine. It extends IF-ELSE-SWITCH constructions of programming languages with concurrency support. The code generated with our approach has been executed with a set of state-machine examples that are part of a test-suite described in the recent OMG standard Precise Semantics Of State Machine. The traced execution results comply with the standard and are a good hint that the execution is semantically correct. The generated code is also efficient: it supports multi-thread-based concurrency, and the (static and dynamic) efficiency of generated code is improved compared to considered approaches.

Paper Nr: 82
Title:

An MDE Approach to Generate Schemas for Object-document Mappers

Authors:

Diego Sevilla, Severino Feliciano and Jesús García-Molina

Abstract: Most NoSQL systems are schemaless. This lack of schema offers a greater flexibility than relational systems. However, this comes at the cost of losing benefits such as the static checking that assure that stored data conforms to the database schema. Instead, developers must be in charge of this task that is time-consuming and error-prone. Object-NoSQL mappers are emerging to alleviate this task and facilitate the development of NoSQL applications. These mappers allow the definition of schemas, which are used to assure that data are correctly manipulated. In this article, we present an MDE approach that automatically generates schemas and other artefacts for mappers. As proof of concept, we have considered Mongoose, which is a widely used mapper for MongoDB, but the solution is mapper-independent. Firstly, the schemas are inferred from stored data by using an approach defined in a previous work. Then, NoSQL schema models are input to a two-step model transformation chain that generates schemas, validators and updating procedures, among other Mongoose artefacts. An intermediate metamodel has been defined to ease the implementation of the transformations. This work shows how MDE techniques can be applied in the emerging “NoSQL Data Engineering” field.

Short Papers
Paper Nr: 5
Title:

On using Sarkar Metrics to Evaluate the Modularity of Metamodels

Authors:

Georg Hinkel and Misha Strittmatter

Abstract: As model-driven engineering (MDE) gets applied for the development of larger systems, the quality assurance of model-driven artifacts gets more important. Here, metamodels are particularly important as many other artifacts depend on them. Existing approaches to measure the modularity of metamodels have not been validated for metamodels thoroughly. In this paper, we evaluate the usage of the metrics suggested by Sarkar et al. to automatically measure the modularity of metamodels with the goal of automated quality improvements. For this, we analyze the data from a previous controlled experiment on the perception of metamodel quality with 24 participants, including both students and academic professionals. From the results, we were able to statistically disprove even a slight correlation with perceived metamodel quality.

Paper Nr: 14
Title:

Security-aware Modeling and Analysis for HW/SW Partitioning

Authors:

Letitia W. Li, Florian Lugou and Ludovic Apvrille

Abstract: The rising wave of attacks on communicating embedded systems has exposed their users to risks of information theft, monetary damage, and personal injury. Through improved modeling and analysis of security, we propose that these flaws could be mitigated. Since HW/SW partitioning, one of the first phases, impacts future integration of security into the system, this phase would benefit from supporting modeling security abstractions and security properties, providing designers with useful partitioning feedback obtained from a security formal analyzer. In this paper, we present how our toolkit supports security modeling, automated security integration, and formal analysis during the HW/SW partitioning phase for secure communications in embedded systems. We introduce “Cryptographic Configurations”, an abstract representation of security that allows us to verify security formally. Our toolkit further assists designers by automatically adding these security representations based on a mapping and security requirements.

Paper Nr: 18
Title:

Creating and Analyzing Source Code Repository Models - A Model-based Approach to Mining Software Repositories

Authors:

Markus Scheidgen, Martin Smidt and Joachim Fischer

Abstract: With mining software repositories (MSR), we analyze the rich data created during the whole evolution of one or more software projects. One major obstacle in MSR is the heterogeneity and complexity of source code as a data source. With model-based technology in general and reverse engineering in particular, we can use abstraction to overcome this obstacle. But, this raises a new question: can we apply existing reverse engineering frameworks that were designed to create models from a single revision of a software system to analyze all revisions of such a system at once? This paper presents a framework that uses a combination of EMF, the reverse engineering framework Modisco, a NoSQL-based model persistence framework, and OCL-like expressions to create and analyze fully resolved AST-level model representations of whole source code repositories. We evaluated the feasibility of this approach with a series of experiments on the Eclipse code-base.

Paper Nr: 22
Title:

Creating User-specific Business Process Monitoring Dashboards with a Model-driven Approach

Authors:

Maximilien Kintz, Monika Kochanowski and Falko Koetter

Abstract: Monitoring with the goal of visualizing key performance indicators using dashboards is an established way of enabling the analysis of business processes and providing quick information in critical situations. Model-driven development and design of these dashboards has proven useful in real world scenarios. However, in large organizations, dashboards need to be role-specific, as not all users are concerned by the same data. In this paper, a users-and-roles model is introduced. It extends and adapts the model-driven process monitoring methodology aPo. With this model, it becomes possible to automatically generate user-specific monitoring dashboards, properly displaying the needed information for each user in an organisation. The implementation is evaluated with a real-world use-case from the service industry.

Paper Nr: 30
Title:

A Domain-specific Language for Configurable Traceability Analysis

Authors:

Hendrik Bünder, Christoph Rieger and Herbert Kuchen

Abstract: In safety-critical industries such as the aviation industry or the medical industry traceability is required by law and specific regulations. In addition, process models such as CMMI require traceability information for documentation purposes. Although creating and maintaing so-called traceability information models (TIM) takes a lot of effort, its potential for reporting development progress, supporting project management, and measuring software quality often remains untapped. The domain-specific language presented in this paper builds on an existing traceability solution and allows to define queries, metrics, and rules for company- or project-specific usage. The basis for such an analysis is a query expression to retrieve information from a TIM. Customizable metrics are then defined to compute aggregated values, which are evaluated against company- or project-specific thresholds using the rules part of the domain-specific language. The focus of this paper is to show how the combination of query, metric, and rule expressions is used to define and compute customizable analyses based on individual requirements.

Paper Nr: 45
Title:

Supporting Software Architecture Evolution by Functional Decomposition

Authors:

David Faitelson, Robert Heinrich and Shmuel Tyszberowicz

Abstract: Software systems evolve during their lifetime to reflect the changes in their users needs. However, unless implemented carefully, such changes may degrade the quality of the system’s architecture by reducing the cohesion and increasing the coupling between its subsystems. It is therefore important to systematically analyze the changes and modify the system’s structure to accommodate the changes without degrading the system’s architecture. However, looking just at functional aspects is not enough, because we may decide on a redesign that is too expensive to implement. In this paper we combine a functional decomposition analysis technique with a nonfunctional impact analysis technique to avoid this pitfall. The functional decomposition technique generates a set of plausible decompositions that accommodate the required evolutionary changes, and the impact analysis technique acts as a filter that selects only those decompositions that satisfy the cost constraints of the required changes. We briefly describe both techniques and then illustrate the approach with an example of a parking lot management system.

Paper Nr: 48
Title:

A Model-Driven fUML Execution Engine for C++

Authors:

Francesco Bedini, Ralph Maschotta, Alexander Wichmann, Sven Jäger and Armin Zimmermann

Abstract: This paper introduces an execution engine that is able to run fUML models, described by a subset of UML's class and activity diagrams' elements. The execution engine is realized in C++, which leads, in certain conditions, to better memory efficiency and performance of the generated code, compared for example to the fUML standard implementation in Java. As it does not use any platform specific code, it is possible to compile it on any C++ compliant platform. The paper then shows how the engine has been applied to a simulated annealing optimization heuristic as a validation example and finally a performance evaluation regarding occupied memory, storage requirements, and execution time is carried out.

Paper Nr: 49
Title:

The Integration of Agile Development and Model Driven Development - A Systematic Literature Review

Authors:

Hessa Alfraihi and Kevin Lano

Abstract: In this paper, we present a Systematic Literature Review (SLR) on combining Agile development and Model- Driven Development (MDD). The objectives of this paper are to identify what are the main characteristics of current Agile Model-Driven Development (Agile MDD) approaches, as well as the benefits and the problems of adopting these approaches. Fifteen publications have been identified and selected as primary studies on which we conducted the analysis. The results show that Agile development and MDD can coexist and benefit from their integration. However, combining Agile and MDD is still in its early stages and more effort is required in research to advance this area. The main contributions of this paper are: detailed and condensed results in the context of current Agile MDD approaches, detailed results on the benefits of Agile MDD in practice, and the observed problems and challenges of the current Agile MDD approaches.

Paper Nr: 53
Title:

Ontology-Driven Conceptual Modeling for Early Warning Systems: Redesigning the Situation Modeling Language

Authors:

João L. R. Moreira, Luís Ferreira Pires, Marten van Sinderen and Patricia Dockhorn Costa

Abstract: An early warning system (EWS) is an integrated system that supports the detection, monitoring and alerting of emergency situations. A possible application of an EWS is in epidemiological surveillance, to detect infectious disease outbreaks in geographical areas. In this scenario, a challenge in the development and integration of applications on top of EWS is to achieve common understanding between epidemiologists and software developers, allowing the specification of rules resulted from epidemiological studies. To address this challenge this paper describes an ontology-based model-driven engineering (MDE) framework that relies on the Situation Modelling Language (SML), a knowledge specification technique for situation identification. Some requirements are realized by revisiting SML, which resulted in a complete redesign of its semantics, abstract and concrete syntaxes. The initial validation shows that our framework can accelerate the generation of high quality situation-aware applications, being suitable for other application scenarios.

Paper Nr: 56
Title:

Axioms of Linguistic Architecture

Authors:

Marcel Heinz, Ralf Lämmel and Andrei Varanovich

Abstract: In documenting software technologies (e.g., web application or modeling or object/relational mapping frameworks) and specifically when discussing technology usage scenarios, one aims at identifying and classifying the involved entities (e.g., languages and artifacts); one also aims at relating the entities (e.g., through conformance or I/O behavior of program execution). In this paper, we present a logic-based axiomatization (an emerging ontology) for the underlying types of entities and relationships, thereby formalizing recurring documentation idioms such as `a software system (e.g., a Java application) to use a technology (e.g., a test library)' or `a technology (e.g., a web application framework) to facilitate a certain concept (e.g., the MVC pattern)'. The axiomatization is illustrated by examples applying to the Eclipse Modeling Framework. The inclusion of types of entities and relationships is driven and thus validated by a literature survey on megamodeling.

Paper Nr: 59
Title:

Measuring the Evolution of Meta-models - A Case Study of Modelica and UML Meta-models

Authors:

Maxime Jimenez, Darko Durisic and Miroslaw Staron

Abstract: The evolution of both general purpose and domain-specific meta-models and its impact on the existing models and modeling tools has been discussed extensively in the modeling research community. To assess the impact of domain-specific meta-model evolution on the modeling tools, a number of measures have been proposed by Durisic et al., NoC (Number of Changes) being the most prominent one. The proposed measures are evaluated on a case of AUTOSARmeta-model that specifies the language for designing automotive system architectures. In this paper, we assess the applicability of these measure and the underlying data-model for their calculation in a case study of Modelica and UML meta-models. Our preliminary results show that the proposed data-model and the measures can be applied to both analyzed meta-models as we were able to capture 68/77 changes on average per Modelica/UML release. However, only a subset of the data-model elements is applicable for analyzing the evolution of Modelica and also certain transformation of the data-model is required in case of UML. Despite these encouraging results, further studies are needed to assess the usefulness of the actual measures, e.g., NoC, in assessing the impact of Modelica/UML meta-model evolution on the modeling tools.

Paper Nr: 60
Title:

Towards Meta-adaptation of Dynamic Adaptive Systems with Models@Runtime

Authors:

Nicolas Ferry, Franck Chauvel, Hui Song and Arnor Solberg

Abstract: A models@runtime environment keeps a model in synchrony with a running system, this way a reasoning engine adapts the system by modifying this model. Existing models@runtime environments typically fail to let the user control what concepts form the model nor how the model is synchronised with the running system. This is yet mandatory in uncertain environments that are open, dynamic and heterogeneous. In this position paper we evolve the classical models@runtime architectural pattern to address this issue, together with some initial implementation results.

Paper Nr: 67
Title:

Model-driven Engineering for the Configuration and Deployment of Data Processing Applications

Authors:

Hui Song, Nicolas Ferry, Jakob Høgenes and Arnor Solberg

Abstract: This position paper reports our current endeavour towards a model-driven engineering framework to support the dynamic configuration and deployment of complex data processing applications. In particular, our approach includes a domain-specific modelling language that abstracts the data processing tasks and at the same time exposes the control of how these tasks are deployed on specific platforms and resources. A modelling framework of model transformation and models@runtime engines realises the semi-automatic configuration and deployment of the applications based on the abstract models.

Paper Nr: 70
Title:

Explicit Control of Dataflow Graphs with MARTE/CCSL

Authors:

Jean-Vivien Millo, Amine Oueslati, Emilien Kaufman, Julien DeAntoni, Frederic Mallet and Robert de Simone

Abstract: Process Networks are a means to describe streaming embedded applications. They rely on explicit representation of task concurrency, pipeline and data-flow. Originally, Data-Flow Process Network (DFPN) representations are independent from any execution platform support model. Such independence is actually what allows looking next for adequate mappings. Mapping deals with scheduling and distribution of computation tasks onto processing resources, but also distribution of communications to interconnects and memory resources. This design approach requires a level of description of execution platforms that is both accurate and simple. Recent platforms are composed of repeated elements with global interconnection (GPU, MPPA). A parametric description could help achieving both requirements. Then, we argue that a model-driven engineering approach may allow to unfold and expand an original DFPN model, in our case a so-called Synchronous DataFlow graph (SDF) into a model such that: a) the original description is a quotient refolding of the expanded one, and b) the mapping to a platform model is a grouping of tasks according to their resource allocation. Then, given such unfolding, we consider how to express the allocation and the real-time constraints. We do this by capturing the entire system in CCSL (Clock Constraint Specification Language). CCSL allows to capture linear but also synchronous constraints.

Paper Nr: 71
Title:

Override Traditional Decision Support Systems - How Trajectory ELT Processes Modeling Improves Decision Making?

Authors:

Noura Azaiez and Jalel Akaichi

Abstract: Business Intelligence is often described as a set of techniques serving the transformation of raw data into meaningful information for business analysis purposes. Thanks to the technology development in the realm of Geographical Information Systems, the so-called trajectory data were appeared. Analysing these raw trajectory data coming from the movements of mobile objects requires their transformation into decisional data. Usually, the Extraction-Transformation-Loading (ETL) process ensures this task. However, it seems inadequate to support trajectory data. Integrating the trajectory aspects gives the birth of Trajectory ETL process (T-ETL). Unfortunately, this is not enough. In fact, the business analysis main purpose is to minimize costs and time consuming. Thus, we propose to swap the T-ETL tasks scheduling: instead of transforming the data before they are written, the Trajectory Extraction, Loading and Transformation (T-ELT) process leverages the target system to achieve the transformation task. In this paper, we rely on a set of powerful mechanisms to handle the complexity of each T-ELT task. Wherefore, an algorithm is dedicated to ensure the transformation of raw mobile object positions into trajectories and from there we highlight the power of the Model-driven Architecture approach to transform the resulting trajectories into analytical data in order to perform the Business Intelligence goal.

Paper Nr: 83
Title:

Towards User-centric DSLs to Manage IoT Systems

Authors:

Moussa Amrani, Fabian Gilson, Abdelmounaim Debieche and Vincent Englebert

Abstract: Hidden behind the Internet of Things (IoT), many actors are activelly filling the market with devices and services. From this profusion of actors, a large amount of technologies and APIs, sometimes proprietary, are available, making difficult the interoperability and configuration of systems for IoT technicians. In order to define and manipulate devices deployed in domestic environments, we propose IoTDSL, a Domain-Specific Language meant to specify, assemble and describe the behaviour of interconnected devices. Relying on a high-level rule-based language, users in charge of the deployment of IoT infrastructures are able to describe and combine in a declarative manner structural configurations as well as event-based semantics for devices. This way, language users are freed from technical aspects, playing with high-level representations of devices, while the complexity of the concrete implementation is handled in a dedicated layer where high-level rules are mapped to vendor’s API.

Posters
Paper Nr: 6
Title:

ATL Transformation of Queueing Networks to Queueing Petri Nets

Authors:

Issam Al-Azzoni

Abstract: This paper presents an approach for model transformation from Queueing Network Models (QNMs) into Queueing Petri Nets (QPNs). This would open up the benefits of QPNs in analyzing the performance of QNMs. We present metamodels for QNMs and QPNs, and then present the transformation rules in the ATL model transformation language. To validate our approach, we apply it to analyze the performance of a QNM and compare the results with those obtained using analytic methods. Although the approach is presented using ATL and Ecore meta modeling language in the context of the Eclipse Modeling Project, it can be realized using other modeling frameworks and languages.

Paper Nr: 7
Title:

World Wide Modeling Made Easy - A Simple, Lightweight Model Server

Authors:

Olivier Le Goaer, Eric Cariou and Franck Barbier

Abstract: Sharing Models across organizations is a good idea but the lack of a tailored and lightweight tool hinders its adoption. In this paper, we explain how to turn any computer into a Model server, which is a server specialized in Models’ location and retrieval. Such a server relies exclusively on specific URIs and commands thereof. The result, called “WWM”, is an out-of-the-box module built upon Node.js. WWM targets the EMF ecosystem and takes the form of a JavaScript API for both server-side and client-side programming.

Paper Nr: 10
Title:

UI-GEAR: User Interface Generation prEview capable to Adapt in Real-time

Authors:

Jenny Ruiz, Estefania Serral and Monique Snoeck

Abstract: User Interface (UI) preview enables UI developers to preview and see the current User Interface before being generated. Despite the many advantages that UI preview could offer, it is not provided by current UI development environments. This paper presents UI-GEAR, a UI generation preview capable to adapt in real-time. UI-GEAR is developed within the MERODE method, a model-driven engineering approach capable to generate a fully functional system prototype from its specification in models. UI-GEAR extends MERODE with a UI development environment that enables developers to play with generation options and to straightforwardly and in real-time visualize the consequences of their choices on the UI to be generated, thus providing them with immediate guidance and design flexibility. We have carried out an experiment with developers with novel experience on designing UIs that demonstrates the advantages of this approach.

Paper Nr: 13
Title:

SEMF – The Semantic Engineering Modeling Framework - Bringing Semantics into the Eclipse Modeling Framework for Space Systems Engineering

Authors:

Tobias Hoppe, Harald Eisenmann, Alexander Viehl and Oliver Bringmann

Abstract: This paper presents an approach to integrate concepts realizing multiple classification and dynamic reclassification into the Eclipse Modeling Framework (EMF) in order to overcome the restricted number of modeling concepts of EMF and the strong class-object-relationship of Java. Hereby, the impact of integrating knowledge modeling approaches – as realized with Protégé – into EMF without extending Java itself is examined. Consequently, objects are configurable during the system development life-cycle by retyping. In combination with reasoning functionality – as known from knowledge management frameworks – several pieces of knowledge can be inferred and checked automatically as illustrated by examples from aerospace industry. As a result, inconsistencies can be revealed much easier leading to considerably less potential for failures and a drastically reduction of follow-on costs. Significant improvements in areas like, object classification, knowledge derivation, and guided system development, are highlighted in this paper.

Paper Nr: 15
Title:

Prevent Collaboration Conflicts with Fine Grained Pessimistic Locking

Authors:

Martin Eyl, Clemens Reichmann and Klaus D. Müller-Glaser

Abstract: There are two main strategies to support the collaboration of software team members working concurrently on the same source code: pessimistic locking and optimistic locking. Optimistic locking is used far more often because a pessimistic lock on the smallest unit stored in the Software Configuration Management (SCM), which is a usually a file, often causes conflict situations, where a developer wants to change the already locked code. Optimistic locking can cause direct and indirect merge conflicts which are costly to resolve and affect productivity. The novelty of our approach is to define a meta-model for the source code (Abstract Syntax Tree) and use pessimistic locking on model artefacts and therefore allow parallel editing of the same class or even method but still preventing direct and indirect merge conflicts. Thereby the developer keeps an isolated workspace and the developer decides when to commit the finished source code. This paper introduces a concept for this solution and a prototype based on Eclipse.

Paper Nr: 17
Title:

Model-to-Model based Approach for Software Component Allocation in Embedded Systems

Authors:

Lujain Al-Dakheel and Issam Al-Azzoni

Abstract: Due to the popularity and heterogeneity of embedded systems, the problem of software component (SW-component) allocation in such systems is receiving increasing attention. Addressing this problem using a graphical modeling language such as Ecore will enable system designers to better and more easily allocate their components. However, the existing Ecore models do not address the problem of SW-component allocation in heterogeneous embedded systems. Because of Ecore informal semantics, Ecore models cannot be analyzed using mathematical tools. On the other hand, an approach based on colored Petri nets (CPNs) was proposed for the modeling and analysis of the software component allocation problem. The approach was shown to be applicable in the field not only with respect to the cost optimization problem, but also because it takes nonfunctional requirements into consideration. In this paper, we propose an approach for the automated transformation of an Ecore model into an equivalent CPN model, which will help the modeler use the power of a formal modeling language by only modeling the system using a simple Ecore-based modeling language.

Paper Nr: 21
Title:

Integrating Interface Modeling and Analysis in an Industrial Setting

Authors:

Ivan Kurtev, Mathijs Schuts, Jozef Hooman and Dirk-Jan Swagerman

Abstract: Precise specification of system component interfaces enables analysis of component behavior and checking of conformance of an implementation to the interface specification. Very often component interfaces are only defined by their signature and without a formal description of the admissible behavior and timing assumptions. In this paper we present a framework named ComMA (Component Modeling and Analysis) that supports model-based engineering (MBE) of high-tech systems by formalizing interface specifications. ComMA provides a family of domain-specific languages that integrate existing techniques from formal behavioral and time modeling and is easily extensible. It contains tools that support different phases of the development process and can be integrated in the industrial way of working. The framework is applied in the context of the family of interventional X-ray machines developed by Philips.

Paper Nr: 27
Title:

Realizing Multi-variant Model Transformations on Top of Reused ATL Specifications

Authors:

Sandra Greiner, Felix Schwägerl and Bernhard Westfechtel

Abstract: Model transformations are crucial in model-driven software engineering (MDSE). While combining MDSE and software product line engineering (SPLE) techniques, summarized as model-driven product line engineering (MDPLE), promises increased productivity by relying on organized reuse, the benefits are impeded by transformation specifications designed exclusively for single-variant models. Applying single-variant model transformations to multi-variant input models results in output models lacking the variability information. Multi-variant model transformations (MVMT), which preserve variability information, have only recently been understood as an explicit research problem. In this paper, we propose an a posteriori approach towards MVMT. Following the paradigm of organized reuse, we propose to employ single-variant model transformations without modifications in a first step, and to transfer variability information afterwards based on the artifacts provided by the single-variant transformation specification. In particular, we implemented this approach for the well-known model-to-model transformation language ATL. To deduce variability information, the execution artifacts (trace and execution model) are analyzed. Then, variability annotations are transfered to the target model automatically. The implementation is evaluated based on a practically example of a Graph product line. Results exhibit that our approach outperforms the conventional solution with respect to user effort, accuracy and performance.

Paper Nr: 31
Title:

Architecture Descriptions of Software Systems: Complex Connectors vs Realisability

Authors:

Mert Ozkaya

Abstract: With the advent of software architectures, architectural languages have become an active research area for the specification of software architectures in terms of components & connectors and for some extra capabilities such as formal analysis and code generation. In this paper, the existing architectural languages have been analysed for two important language features - i.e., interaction protocols and realisability. The analysis results show that only a few languages support interaction protocols via their first-class connector elements (also referred to as complex connectors). However, complex connectors of those languages lead to unrealisable specifications due to enabling global constraints which may not be possible for distributed systems. Therefore, practitioners cannot implement the system in the way specified, and any analyses (e.g., performance) made on the unrealisable specifications will all be invalid.

Paper Nr: 33
Title:

Model-driven Approach for Privacy Management in Business Ecosystem

Authors:

Christophe Feltus, Eric Grandry, Thomas Kupper and Jean-Noël Colin

Abstract: Protection of individuals with regard to the processing of personal data and the free movement of such data constitutes new challenges in terms of privacy management. Although this privacy management ought to be conducted in compliance with national and international regulation, for now we observe that no solution, model or method, fully consider and integrate these new regulations yet. Therefore, in this paper, we propose to tackle this problem through the definition of an expressive privacy metamodel which aims to represent and aggregate the concepts that are relevant to define and to deal with privacy issues, at an organizational level. Secondly, we discuss how this privacy metamodel may support and may help understanding the management of the privacy in enterprises involve in interconnected societies, by integrating the privacy metamodel with the systemic business ecosystem.

Paper Nr: 35
Title:

An Approach to Pruning Metamodels like UML

Authors:

Zhiyi Ma

Abstract: There are a large number of modeling languages based on metamodels, and many of the languages are large and complex. In many cases, only part of a metamodel is needed. Hence, it is necessary to automatically extract needed part from a metamodel. By deeply analyzing the characteristics such as special relations between packages and step-by-step strictly defining mechanism of modeling concepts, this paper presents an approach to pruning metamodels like UML as needed. The approach can effectively prune metamodels, control the size of pruned metamodels, and make pruned metamodels comply with its initial metamodels.

Paper Nr: 57
Title:

Model-based Development of Modular Complex Systems for Accomplishing System Integration for Industry 4.0

Authors:

Kunal Suri, Arnaud Cuccuru, Juan Cadavid, Sebastien Gerard, Walid Gaaloul and Samir Tata

Abstract: Industry 4.0 provides a framework for integration of cyber-physical systems (CPS), internet of things (IoT), internet of services (IoS) and internet of data (IoD) with the manufacturing domain so as to make it smart, flexible and adaptable to the dynamic market changes and the customer requirements. It will enable companies to form a connected "smart manufacturing" ecosystem having interconnections between the suppliers, manufacturers, distributors and even the products in order to provide better services to the end customer. However, due to the presence of heterogeneous systems that might not adhere to the industrial standards, there is a gap in achieving this vision of an interconnected ecosystem. In this paper, we focus on providing a solution for the modularity and interoperability issues related to the Industry 4.0 from a systems integration viewpoint. We propose a model-based approach for modular complex systems development by separating (1) the behavior model and (2) the implementation logic (execution) of the system. Moreover, we use unified modeling language (UML) based modeling techniques to model system behavior and connect the behavior models to the application programming interface (API) of the CPS. Thus, instead of generating source code for the CPS using models, we directly execute the CPS in the physical world via model execution. The model execution is supported by the standard execution semantics of UML. Using our approach, multiple heterogeneous systems can be modeled and integrated together to create a "plug and play" ecosystem needed for achieving the vision of Industry 4.0.

Paper Nr: 63
Title:

On using Colors in UML Models

Authors:

Gefei Zhang

Abstract: Using colors has been recognized by Software Engineering research as helpful to make graphical software models more comprehensible. However, guidelines of where and how to use colors have been only little investigated yet. In this paper, we give two simple examples and propose some guidelines of where and how to use colors in UML models efficiently. Our guidelines may provide valuable help to use colors as a visual aid of software models and thus reduce the cognitive load of software developers in Model Driven Engineering.

Paper Nr: 64
Title:

Consistent Projectional Text Editors

Authors:

S. M. Guttormsen, A. Prinz and T. Gjøsæter

Abstract: For modelling and domain-specific languages, projectional editors have become popular. These editors implement the MVC pattern and provide a direct connection to the underlying model. In particular, projectional editors allow much more freedom in defining the concrete syntax than traditional grammars. The downside is that it is possible to define presentations that are of bad quality, and that this is not easily visible. In this article, we identify some of the problems with projectional editors and propose ways to resolve them. We also demonstrate a proof-of-concept solution, showing how problematic editor presentations could be identified automatically.

Paper Nr: 78
Title:

Towards Including Layout Properties for Modeling Graphical User Interfaces - Generic Properties for GUI Metamodels

Authors:

Sarra Roubi, Mohammed Erramdani and Samir Mbarki

Abstract: Software applications have come to simplify the task for users and offer them automated functionalities. These applications must therefore contain high-performance and efficient user interfaces in order to translate correctly the user’s needs. Indeed, several elements contribute to the ergonomics of these interfaces, among them the position and layout of the graphical components which play a very important role to ensure this. However, the design and implementation of such user interfaces for different platform using several programming languages can be tedious and time consuming, especially when the application gathers a large number of interfaces or screens. Since the model driven engineering aims at automating the process of development and raising the level of abstraction, we can use model driven principles to help users choose the right component in the right position on the interface. That is why we present an approach that combines model driven engineering principles and the graphical user interfaces to handle automated layout and position.