MODELSWARD 2018 Abstracts


Area 1 - Applications and Software Development

Full Papers
Paper Nr: 30
Title:

Reusing Platform-specific Models in Model-Driven Architecture for Software Product Lines

Authors:

Frédéric Verdier, Abdelhak-Djamel Seriai and Raoul Taffo Tiam

Abstract: One of the main concerns of software engineering is the automation of reuse in order to produce high quality applications in a faster and cheaper manner. Model-Driven Software Product Line Engineering is an approach providing solutions to systematically and automatically reuse generic assets in software development. More specifically, some solutions improve the product line core assets reusability by designing them according to the Model-Driven Architecture approach. However, existing approaches provide limited reuse for platform-specific assets. In fact, platform-specific variability is either ignored or only partially managed. These issues interfere with gains in productivity provided by reuse. In this paper, we first provide a better understanding of platform-specific variability by identifying variation points in different aspects of a software based on the well-known "4+1" view model categorization. Then we propose to fully manage platform-specific variability by building the Platform-Specific-Model using two sub-models: the Cross-Cutting Model, which is obtained by transformation of the Platform-Independent Model, and the Application Structure Model, which is obtained by reuse of variable platform-specific assets. The approach has been experimented on two concrete applications. The obtained results confirm that our approach significantly improves the productivity of a product line.

Paper Nr: 54
Title:

Towards a Test Specification Language for Information Systems: Focus on Data Entity and State Machine Tests

Authors:

Alberto Rodrigues da Silva, Ana C. R. Paiva and Valter Emanuel R. da Silva

Abstract: This paper introduces the TSL language (short name for “Test Specification Language”) that intends to improve the test specification of information systems in a systematic, rigorous and consistent way. TSL specifications are produced from close requirement specifications expressed in the RSL language (Requirements Specification Language). Both RSL and TSL support human-readable executable specifications closer to natural language than models usually used in model-based testing approaches. TSL includes several constructs logically arranged into views according to multiple testing engineering strategies, commonly found in the information systems domain, such as: data entity tests and state machine tests, all of them produced from equivalent requirement specification in RSL. A case study is also presented to illustrate the proposed approach.

Paper Nr: 87
Title:

Fast Simulation Preorder Algorithm

Authors:

Evgeny Kusmenko, Igor Shumeiko, Bernhard Rumpe and Michael von Wenckstern

Abstract: Automotive industry uses model checking approaches to ensure behavioral backward compatibility of different variants and versions of software components to enable higher re-usability. Due to the lack of scalability, our already presented backward model-checking approach only allowed compatibility checks for small and mid-size components. Therefore, this paper presents several optimizations, such as normalizing and hashing the Expression Abstract Syntax Tree for faster evaluations and the creation of mappings for internal Simulink variables to avoid the need to unfold them. These optimizations lead to a tremendous decrease in execution time of our backward-compatibility checks between MATLAB Simulink components enabling the support of larger models. Besides describing the methodology behind the new fast simulation preorder algorithm, this paper also evaluates the different steps of the new algorithms for a driver assistant system provided by Daimler AG.

Short Papers
Paper Nr: 78
Title:

Using Structure of Automata for Faster Synchronizing Heuristics

Authors:

Berk Cirisci, Muhammed Kerem Kahraman, Cagri Uluc Yildirimoglu, Kamer Kaya and Husnu Yenigun

Abstract: The problem of finding a synchronizing sequence for an automaton is an interesting problem studied widely in the literature. Finding a shortest synchronizing sequence is an NP-Hard problem. Therefore, there are heuristics to find short synchronizing sequences. Some heuristics work fast but produce long synchronizing sequences, whereas some heuristics work slow but produce relatively shorter synchronizing sequences. In this paper we propose a method for using these heuristics by considering the connectedness of automata. Applying the proposed approach of using these heuristics make the heuristics work faster than their original versions, without sacrificing the quality of the synchronizing sequences.

Paper Nr: 79
Title:

Modeling a Tool for Conducting Systematic Reviews Iteratively

Authors:

Brice Bigendako and Eugene Syriani

Abstract: Conducting systematic reviews (SR) is a time-consuming endeavor that requires several iterations to setup right. We present ReLiS, a tool to automatically install and configure SR projects to conduct them collaboratively and iteratively on the cloud. ReLiS is engineered following a model-driven development approach. It features a domain-specific modeling editor tailored for researchers who perform SR and an architecture that enables on-the-fly installation and (re)configuration of multiple concurrently running SR projects.

Posters
Paper Nr: 6
Title:

Qualitative Simulation of Hybrid Systems with an Application to SysML Models

Authors:

Slim Medimegh, Jean-Yves Pierron and Frédéric Boulanger

Abstract: Hybrid systems are specified in a heterogeneous form, with discrete and continuous parts. Simulating such systems requires precise data and synchronization of continuous changes and discrete transitions. However, in the early design stages, missing information forbids numerical simulation. We present here a symbolic execution model for the qualitative simulation of hybrid systems, which consists in computing only qualities of the behavior. This model is implemented in the Diversity symbolic execution engine to build the qualitative behaviors of the system. We apply this approach to the analysis of SysML models, using an M2M transformation from SysML to a pivot language and an M2T transformation from this language to Diversity.

Paper Nr: 52
Title:

Pattern based Web Security Testing

Authors:

Paulo J. M. Araújo and Ana C. R. Paiva

Abstract: This paper presents a Pattern Based Testing approach for testing security aspects of the applications under test (AUT). It describes the two security patterns which are the focus of this work (``Account Lockout'' and ``Authentication Enforcer'') and the test strategies implemented to check if the applications are vulnerable or not regarding these patterns. The PBST (Pattern Based Security Testing) overall approach has two phases: exploration (to identify the web pages of the application under test) and testing (to execute the test strategies developed in order to detect vulnerabilities). An experiment is presented to validate the approach over five public web applications. The goal is to assess the behavior of the tool when varying the upper limit of pages to visit and assess its capacity to find real vulnerabilities. The results are promising. Indeed, it was possible to check that the vulnerabilities detected corresponded to real security problems.

Area 2 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 45
Title:

A Process-oriented Build Tool for Safety-critical Model-based Software Development

Authors:

Markus Hochstrasser, Stephan Myschik and Florian Holzapfel

Abstract: By conquering new application areas, software complexity and size increases steadily. Development cycles must become faster to deliver critical updates in shorter time. Simultaneously, software takes over more and more safety-critical tasks, requiring strict software development processes. Up to today, these processes suffer from extensive manual review work and written, static documentation in form of standards, checklists, and procedures. This paper presents a monolithic, process-oriented build tool for model-based development in MATLAB, Simulink, and Stateflow. Beyond classical build automation functionality, it supports and accelerates process workflows. The tool provides infrastructure to formalize and ship workflows, checklists, and standards, but also features to assess completeness, consistency, compliance, and cleanliness with respect to them. Additionally, it allows definition of dynamic, incrementally updated checklists, and composes traceability in parallel with the build. The efficacy and achievable process coverage is demonstrated in an example application.

Paper Nr: 53
Title:

Cost-aware Scheduling of Software Processes Execution in the Cloud

Authors:

Sami Alajrami, Alexander Romanovsky and Barbara Gallina

Abstract: Using cloud computing to execute software processes brings several benefits to software development. In a previous work, we proposed a reference architecture, which treats software processes as workflows and uses cloud computing to execute them. Scheduling the execution in the cloud impacts the execution cost and the cloud resources utilization. Existing workflow scheduling algorithms target business and scientific (data- driven) workflows, but not software processes workflows. In this paper, we adapt three scheduling algorithms for our architecture and propose a fourth one; the Proportional Adaptive Task Schedule algorithm. We evaluate the algorithms in terms of their execution cost, makespan and cloud resource utilization. Our results show that our proposed algorithm saves between 19.74% and 45.78% of the execution cost and provides the best resource (virtual machine) utilization compared to the adapted algorithms while providing the second best makespan.

Paper Nr: 59
Title:

Test Generation for Performance Evaluation of Mobile Multimedia Streaming Applications

Authors:

Mustafa Al-tekreeti, Kshirasagar Naik, Atef Abdrabou, Marzia Zaman and Pradeep Srivastava

Abstract: In this paper, we propose a model based test generation methodology to evaluate the impact of the interaction of the wireless network and the application (app) configurations on the performance of a mobile multimedia streaming app. The methodology requires four artefacts as inputs, namely, a behaviour model of the software under test (SUT), a network model, a test coverage criterion, and desired performance levels. The methodology consists of three steps. First, two performance models are developed: mathematical and simulation. Second, to evaluate the end-user quality of experience (QOE), test generation is formulated as an inversion problem. To account for different types of performance models, the inversion problem is solved as an optimization problem. Third, the necessary information to execute test cases is inferred using the simulation model. Two test coverage criteria are proposed: user-experience (UE) and user-experience-and-input-interaction (UEII). The mathematical performance model for a streaming app is developed using Markov chain. To account for realistic network behaviours, the Markov chain is solved using the supplementary variable technique (SVT). A reusable network model is developed for a mobile device that has a network access through a WiFi LAN. Finally, the effectiveness of the methodology is evaluated in comparison with random testing.

Short Papers
Paper Nr: 7
Title:

Evolving Attacker Perspectives for Secure Embedded System Design

Authors:

Letitia W. Li, Florian Lugou and Ludovic Apvrille

Abstract: In our increasingly connected world, security is a growing concern for embedded systems. A systematic design and verification methodology could help detect vulnerabilities before mass production. While Attack Trees help a designer consider the attacks a system will face during a preliminary analysis phase, they can be further integrated into the design phases. We demonstrate that explicitly modeling attacker actions within a system model helps us to evaluate its impact and possible countermeasures. This paper describes how we evolved the SysML-Sec Methodology with “Attacker Scenarios” for the improved design of secure embedded systems.

Paper Nr: 8
Title:

Multi-level Latency Evaluation with an MDE Approach

Authors:

Daniela Genius, Letitia W. Li, Ludovic Apvrille and Tullio Tanzi

Abstract: Designing embedded systems includes two main phases: (i) HW/SW Partitioning performed from high-level functional and architecture models, and (ii) Software Design performed with significantly more detailed models. Partitioning decisions are made according to performance assumptions that should be validated on the more refined software models. In this paper, we focus on one such metric: latencies between operations. We show how they can be modeled at different abstraction levels (partitioning, SW design) and how they can help determine accuracy of the computational complexity estimates made during HW/SW Partitioning.

Paper Nr: 18
Title:

Formal, Model- and Scenario-based Requirement Patterns

Authors:

Markus Fockel, Jörg Holtmann, Thorsten Koch and David Schmelter

Abstract: Distributed, software-intensive systems such as automotive electronic control units have to handle various situations employing message-based coordination. The growing complexity of such systems results in an increasing difficulty to achieve a high quality of the systems’ requirements specifications. Scenario-based requirements engineering addresses the message-based coordination of such systems and enables, if underpinned with formal modeling languages, automatic analyses for ensuring the quality of requirements specifications. However, formal requirements modeling languages require high expertise of the requirements engineers and many manual iterations until specifications reach high quality. Patterns provide a constructive means for assembling high-quality solutions by applying reusable and established building blocks. Thus, they also gained momentum in requirements documentation. In order to support the requirements engineers in the systematic conception of formal, scenario-based requirements specification models, we hence introduce in this paper a requirement pattern catalog for a requirements modeling language. We illustrate and discuss the application of the requirement patterns with an example of requirements for an automotive electronic control unit.

Paper Nr: 21
Title:

Towards Domain-specific Flow-based Languages

Authors:

Bahram Zarrin, Hubert Baumeister and Hessam Sarjoughian

Abstract: Due to the significant growth of the demand for data-intensive computing, in addition to the emergence of new parallel and distributed computing technologies, scientists and domain experts are leveraging languages specialized for their problem domain, i.e., domain-specific languages, to help them describe their problems and solutions, instead of using general purpose programming languages. The goal of these languages is to improve the productivity and efficiency of the development and simulation of concurrent scientific models and systems. Moreover, they help to expose parallelism and to specify the concurrency within a component or across different independent components. In this paper, we introduce the concept of domain-specific flow-based languages which allows domain experts to use flow-based languages adapted to a particular problem domain. Flow-based programming is used to support concurrency, while the domain-specific part of these languages is used to define atomic processes and domain-specific validation rules for composite processes. We propose a modeling language that can be used to develop such domain-specific languages. Since this language allows one to define other languages, we often refer to it as a meta-modeling language.

Paper Nr: 38
Title:

An Ontological Context Modeling Framework for Coping with the Dynamic Contexts of Cyber-physical Systems

Authors:

Jennifer Brings, Marian Daun, Constantin Hildebrandt and Sebastian Törsleff

Abstract: Cyber-physical systems are highly collaborative by nature. At runtime these systems collaborate with each other to achieve goals that a single system could not achieve on its own. For example, autonomous vehicles can dynamically form convoys at runtime to facilitate higher traffic throughput and a reduction in CO2 emissions. While the importance of context documentation and analysis in system development is well known, current model-based engineering approaches struggle with the size and complexity of cyber-physical systems’ contexts. This is due to high variety and dynamicity of the contexts to be considered. For example, a convoy to be formed at runtime may consist of different numbers of participating vehicles. Additionally, it may face different neighboring, not partaking context systems (e.g., non-equipped vehicles, equipped but not participating vehicles) and situations (e.g., speed limits, road construction sites, emergency vehicles). This paper proposes a context ontology to cope with highly dynamic contexts of cyber-physical systems by explicitly differentiating between not only the system and its context but also between the cyber-physical system network the system participates in, as well as the system network’s context.

Paper Nr: 47
Title:

Information Extraction from High-level Activity Diagrams to Support Development Tasks

Authors:

Martin Beckmann, Thomas Karbe and Andreas Vogelsang

Abstract: As the complexity of systems continues to increase, the use of model-driven development approaches becomes more widely applied. One of our industry partners (Daimler AG) uses UML activity diagrams as the first step in the development of vehicle functions, mainly for the purpose of communication and overview. However, the contained information is also valuable for further development tasks. In this paper, we present an automated approach to extract information from these high-level activities. We put a focus on aspects of activities such as propositional logic relations, sequences of actions, and differentiability of execution paths. The extracted parts are needed for the compilation of requirements and the creation of test cases. Also, this approach supports stakeholders unfamiliar with the notations of activities as implicit information is made explicit and hence more accessible. For this purpose, we provide a formalism for the kind of activities our industry partner uses. Based on that formalism, we define properties that express the contained sequences and execution paths. Furthermore, the formalism is used to derive the underlying propositional logic relations. We show how the approach is applied to eliminate hundreds of existing quality issues in an existing requirements document.

Paper Nr: 68
Title:

An Y MDE Approach for Enactable Software Process Models Generation

Authors:

Samba Diaw, Mamadou Lakhassane Cisse and Alassane Bah

Abstract: The advent of MDE enabled to automate software development while reducing its production time. While software companies need continually to improve and customize their software processes, an automated approach to do so is still lacking. Most of those companies have an organizational process that is used whenever they have an upcoming development project. Reusing the same process for any development project is somehow inadequate. So, tailoring of such a process is necessary to fit organisational and operational companies’ needs. However, even if that tailored process can be used for a specific project, it still lacks resources needed for execution. In this short paper, we propose a Y model-based approach that allows tailoring software processes and generating enactable software process models by using models transformations. We defined metamodels to express models involved in those transformations. We illustrate our approach with an extract of the UWE Process which we adapt and instantiate for a development project with .Net.

Paper Nr: 77
Title:

Cost-Risk Optimization Applied in the Context of Regulation

Authors:

Ibtissem Chouba and Jean-Sébastier Sottet

Abstract: Most engineering, maintenance and operating decisions involve some aspect of Cost/risk trade-off. In this context we will talk about the cost- risk optimization applied to information systems in the context of application of regulations. In this paper, a conceptual model of risk based regulation, based on the existing business and risk architecture models will be presented. Then, a conceptual cost-risk model associated with the implementation of risk mitigating controls will be adopted and integrated into the optimization approach. Following this cost model, a mixed-integer linear program will be described. The bi-objective optimization of the risk-cost will then be solved with IBM ILOG CPLEX optimizer to define an optimized solution. The result of the calculation of the optimization will serve as a help to the decision-making of the company.

Paper Nr: 88
Title:

Context-specific Quality Evaluation of Test Cases

Authors:

Ivan Jovanovikj, Vishwak Narasimhan, Gregor Engels and Stefan Sauer

Abstract: Software systems are continuously changed during maintenance and evolution. To ensure their quality, they have to be tested. But before starting testing a software system, the quality of the test cases themselves has to be evaluated. Due to the changes of the software system, they might have become obsolete or even erroneous. Furthermore, test cases created in an industrial setting are extensive and at some point of time, they might have become difficult to understand, unmanageable and inefficient. Therefore, by evaluating their quality, we can better understand, control and eventually improve the quality of test cases. We present the Test Case Quality Plan (TCQP) approach, which is based on the GQM (Goal-Question-Metric) approach and enables a systematic and efficient development of quality plans. They serve as a guideline for the quality evaluation of test cases, and emphasize the context of use of test cases as a major factor of influence for the whole quality evaluation. The TCQP approach has been applied and evaluated in an industrial case study.

Posters
Paper Nr: 4
Title:

Towards an Implementation of Data and Resource Patterns in Constraint-based Process Models

Authors:

Stefan Schönig, Lars Ackermann and Stefan Jablonski

Abstract: A Process-Aware Information System (PAIS) is a system that executes processes involving people, applications, and data on the basis of process models. Two representations for processes can be distinguished: procedural models prescribe exactly the execution order of process steps. Declarative process models allow flexible process executions that are restricted by constraints. Especially in application areas of knowledge driven processes, this flexibility is required. Foundations of declarative approaches have been extensively discussed in research. From a practitioner’s point of view, however, an open question still remains: is it possible to implement established functionality in contemporary declarative PAIS, especially data and resource handling? In this paper, we tackle this open research question by introducing the declarative process modelling and execution framework DPIL that covers resource and data modelling. Expressiveness and functionality of the framework are evaluated by means of the well-known Workflow Data and Resource Patterns.

Paper Nr: 65
Title:

Multi-Concerns Engineering for Safety-Critical Systems

Authors:

Philipp Lohmüller, Andrea Fendt and Bernhard Bauer

Abstract: Modern cars are equipped with a large number of electronic assistance systems such as Adaptive Cruise Control (ACC) to improve road safety and driving comfort. These systems require a complex cross-linking, both inside and outside the vehicle, e.g., by means of bus systems or wireless interfaces like Bluetooth. Thus, safety of road users can endangered if the communication between these systems failed. Communication failures can be affected by hacking attacks, e.g., delayed decelerating of an ACC system, thereby presenting a security and timing vulnerability endangering safety of road users. Hence, in this paper safety is considered as primary goal. Goals that contribute to achieve the primary goal can be in contradiction to each other under certain circumstances. Therefore, an approach is proposed to model Safety, Security and Timing (SST) constraints to guarantee maximum safety. Furthermore, a preventative risk assessment of the individual concerns including a tradeoff analysis is performed to enable the development of Safety-Critical Systems (SCS).

Paper Nr: 85
Title:

A Meta-model based Automatic Conceptual Model-to-Model Transformation Methodology

Authors:

Tiexin Wang, Sebastien Truptil, Frédérick Benaben and Chuanqi Tao

Abstract: Since model-based engineering theories and techniques becoming mature gradually, diverse engineering domains have adopted the idea of employing modelling and model transformations to help simulate and analyze domain specific problems. Consequently, substantial numbers of modelling techniques have been developed. These modelling techniques define specific semantic and syntactic representations. Moreover, models are normally built to represent systems from diverse domains. Both the conceptual dissimilarities between modelling techniques and between diverse systems determine the particularity of models. In model transformation process, distinguishing the conceptual difference from both semantic and syntactic aspects is a time-consuming process relying mainly on manual effort. In order to remove the manual effort from model transformation process, this paper proposes a generic automatic conceptual model-to-model transformation methodology. This methodology employs semantic and syntactic checking measurements to automatically detect the conceptual dissimilarities, and aims to solve both domain specific problems and cross-domain problems. A refined meta-model based model transformation process is defined to better use the two checking measurements.

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 3
Title:

A Model-Driven Method for Fast Building Consistent Web Services in Practice

Authors:

David Sferruzza, Jérôme Rocheteau, Christian Attiogbé and Arnaud Lanoix

Abstract: Nowadays, lots of software companies rely on web technologies to test market hypothesis and develop viable businesses. They often need to quickly build web services that are at the core of their Minimum Viable Products (MVPs). MVPs must be reliable and are based on specifications and hypothesis that are likely to change. Model Driven Engineering approaches have been proposed and used to develop and evolve web services. However, these approaches lack the ability to be suitable for both (i) rapid prototyping, (ii) model verification and (iii) compatibility with common programming languages. Here we propose a meta-model to express web services and the related tool to verify models consistency. We adopt a shallow verification process to allow rapid prototyping by developers who are not formal methods experts, while still offering design-time guarantees that improve product quality and development efficiency. Web services are defined using parametric components which enable to express and formally verify web service patterns and to safely reuse them in other contexts. We built a tool to check consistency of models and associated components implementations in order to generate corresponding web services. This allows us to give flexibility to developers, as well as verification support and an easier onboarding for new developers.

Paper Nr: 5
Title:

A Model Compilation Approach for Optimized Implementations of Signal-processing Systems

Authors:

Andrea Enrici, Julien Lallet, Imran Latif, Ludovic Apvrille, Renaud Pacalet and Adrien Canuel

Abstract: To meet the computational and flexibility requirements of future 5G networks, the signal-processing functions of baseband stations and user equipments will be accelerated onto programmable, configurable and hard-wired components (e.g., CPUs, FPGAs, hardware accelerators). Such mixed architectures urge the need to automatically generate efficient implementations from high-level models. Existing model-based approaches can generate executable implementations of Systems-on-Chip (SoCs) by translating models into multiple SoC-programming languages (e.g., C/C++, OpenCL, Verilog/VHDL). However, these translations do not typically consider the optimization of non-functional properties (e.g., memory footprint, scheduling). This paper proposes a novel approach where system-level models are optimized and compiled into multiple implementations for different SoC architectures. We show the effectiveness of our approach with the compilation of UML/SysML models of a 5G decoder. Our solution generates both a software implementation for a Digital Signal Processor platform and a hardware-software implementation for a platform based on hardware Intellectual Property (IP) blocks. Overall, we achieve a memory footprint reduction of 80.07% in the first case and 88.93% in the second case.

Paper Nr: 9
Title:

Generating Multi-Variant Java Source Code Using Generic Aspects

Authors:

Sandra Greiner and Bernhard Westfechtel

Abstract: Model-driven product line engineering (MDPLE) aims at increasing productivity when realizing a family of related products. Relying on model-driven software engineering (MDSE) seeks to support this effect by using models raising the level of abstraction. In MDSE model transformations are successfully applied to transform in between different (model) representations. During MDPLE models based on negative variability are augmented with variability information, we refer to as annotations. To derive products, source code is generated in model-to-text (M2T) transformations. However, applying single-variant model transformations (SVMT) to annotated models, typically loses the information in the output as SVMTs are not capable to process annotations. This work contributes a solution which reuses existing SVMTs without changing them and which transfers annotations to the output orthogonally to the reused transformation. In particular, we contribute generic aspects, supporting any kind of input metamodel, to augment the outcome of (M2T) SVMTs with annotations. Producing multi-variant source code (MVSC) is advantageous because all variants are reflected in the output. Thus, changes made inside the MVSC can be integrated easily in all concerned products upon their derivation. Otherwise, this needs to be done manually in a cumbersome process contradicting the purpose of MDPLE, to raise productivity.

Paper Nr: 10
Title:

Predicting the Perceived Modularity of MOF-based 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 becomes more important. Here, metamodels are particularly important as many other artifacts depend on them. However, existing metrics have been rarely validated for metamodels or, even more, evaluation results disproved a correlation between these existing metrics and perceived metamodel modularity. In this paper, we present a new entropy-based metric to capture the perception of metamodel modularity and evaluate the metric in multiple case studies. In the case studies, we correlate the metric results of 32 metamodels across three different domains with 164 responses of a quality assessment questionnaire for which we collected responses in two empirical experiments. The results show significant and strong correlations in all three domains between the metric results and the perceived metamodel modularity.

Paper Nr: 13
Title:

Virtual Extension of Meta-models with Facet Tools

Authors:

Jonathan Pepin, Pascal André, Christian Attiogbé and Erwan Breton

Abstract: MDE emphasizes the use of models and meta-models to improve the software productivity and some aspects of the software quality such as maintainability or interoperability. In the software industry, Model Driven Engineering (MDE) techniques have proven useful not only for developing new software applications but for re-engineering legacy systems. However the stakeholders have to face costly maintenance operations due to frequent new standards and upgraded releases of software modules they depend on. Therefore, due to the limitations of existing techniques, solutions ensuring a better adaptability and flexibility of model evolution tools are needed. We propose an improved technique of virtual extension of meta-models with Facets that enables one to modify meta-models already in use without rebuilding completely the software product. This technique has been implemented and experimented for model alignment and evolution.

Paper Nr: 19
Title:

DoMoRe – A Recommender System for Domain Modeling

Authors:

Henning Agt-Rickauer, Ralf-Detlef Kutsche and Harald Sack

Abstract: Domain modeling is an important activity in early phases of software projects to achieve a shared understanding of the problem field among project participants. Domain models describe concepts and relations of respective application fields using a modeling language and domain-specific terms. Detailed knowledge of the domain as well as expertise in model-driven development is required for software engineers to create these models. This paper describes DoMoRe, a system for automated modeling recommendations to support the domain modeling process. We describe an approach in which modeling benefits from formalized knowledge sources and information extraction from text. The system incorporates a large network of semantically related terms built from natural language data sets integrated with mediator-based knowledge base querying in a single recommender system to provide context-sensitive suggestions of model elements.

Paper Nr: 20
Title:

An Integrated Framework to Specify Domain-Specific Modeling Languages

Authors:

Bahram Zarrin and Hubert Baumeister

Abstract: In this paper, we propose an integrated framework that can be used by DSL designers to implement their desired graphical domain-specific languages. This framework relies on Microsoft DSL Tools, a meta-modeling framework to build graphical domain-specific languages, and an extension of ForSpec, a logic-based specification language. The drawback of MS DSL Tools is it does not provide a formal and rigorous approach for semantics specifications. In this framework, we use Microsoft DSL Tools to define the metamodel and graphical notations of DSLs, and an extended version of ForSpec as a formal language to define their semantics. Integrating these technologies under the umbrella of Microsoft Visual Studio IDE allows DSL designers to utilize a single development environment for developing their desired domain-specific languages.

Paper Nr: 28
Title:

A Fully Implemented Didactic Tool for the Teaching of Interactive Software Systems

Authors:

Jenny Ruiz, Estefania Serral and Monique Snoeck

Abstract: User Interface (UI) design and software engineering complement each other to develop useful and usable interactive software systems. However, the body of knowledge for the development of an application and for the design of its UI are not always well integrated. The problem starts in the education of both subjects, which are normally taught independently of each other. Although an integrative teaching approach can significantly contribute to the development of better interactive software systems, there is a lack of concrete and proven approaches for such way of teaching. This paper presents a fully functional didactic tool for filling this gap. This tool provides the learner with feedback about how to develop an application and how to design a proper UI for it. Applying Model Driven Engineering principles, the tool automatically generates a working prototype of the interactive software system from its specification models, allowing the learner to try out the final application and validate the requirements. An experiment with novice developers demonstrates the advantages of this didactic tool.

Paper Nr: 32
Title:

Towards Interactive Mining of Understandable State Machine Models from Embedded Software

Authors:

Wasim Said, Jochen Quante and Rainer Koschke

Abstract: State machines are an established formalism for specifying the behavior of a software component. Unfortunately, such design models often do not exist at all, especially for legacy code, or they are lost or not kept up to date during software evolution – although they would be very helpful for program comprehension. Therefore, it is desirable to extract state machine models from code and also from legacy models. The few existing approaches for that – when applied to real-world systems written in C – deliver models that are too complex for being comprehensible to humans. This is mainly because C functions are typically much longer than object oriented methods, for which these approaches were originally intended. In this paper, we propose and investigate different measures to reduce the complexity of such mined models to an understandable degree. Since the code alone does not contain all required information for abstraction, user interaction is essential. Also, different users will be interested in different aspects of the code. Therefore, we introduce several possibilities for influencing the state machine extraction process, such as providing additional constraints for reducing the state space. We show the effectiveness of these interactions in several case studies. The combination of these interactions gives the user a rich set of possibilities for exploring the functionality of the software.

Paper Nr: 33
Title:

Reducing UML Modeling Tool Complexity with Architectural Contexts and Viewpoints

Authors:

Maged Elaasar, Florian Noyrit, Omar Badreddin and Sébastien Gérard

Abstract: UML modeling tools are notoriously hard to use for many reasons, including complexity of the language, weak support for methodologies, and insensitivity to users’ concerns. This is manifested in tools that expose all of their capabilities at once, overwhelming users. The problem is exacerbated when a tool supports multiple domain-specific languages that are defined on top of UML. In this case, the tool customizations necessary for each language may interfere with each other and exacerbate the complexity further. In this paper, we discuss an approach to reduce the complexity of UML tools by implementing and adapting the ISO 42010 standard on architecture description. In this approach, the notions of architecture contexts and architecture viewpoints allow heterogeneous UML-based languages to be independently supported and help contextualize the exposed tool capabilities to them. We present a case study where we defined several architecture contexts, and provided an implementation for them in the Papyrus modeling tool. The implementation of this novel approach demonstrated the ability for multiple architecture contexts to coexist without interference and provided significant reduction in the exposed capabilities in the UI.

Paper Nr: 36
Title:

Analyzing Frame Conditions in UML/OCL Models - Consistency Equivalence and Independence

Authors:

Philipp Niemann, Nils Przigoda, Robert Wille and Rolf Drechsler

Abstract: In behavioral modeling using UML/OCL, operation contracts defined by pre- and postconditions describe the effects on model elements (such as attributes, links, etc.) that are enforced by an operation. However, it is usually not clearly stated which model elements can be affected and which shall not, although this information is essential in order to obtain a comprehensive description. A promising solution to this so-called frame problem is to define additional frame conditions. However, properly defining frame conditions which complete the model description in the intended way is a non-trivial, tedious and error-prone task. While for UML/OCL models in general, methods for validation and verification are available, no analysis methods for frame conditions exist so far that could support the designer in this process. In this work, we close this gap and propose a set of primary analysis objectives (namely consistency, equivalence, and independence) that provide substantial information about the correctness and adequateness of given frame conditions. Moreover, we formalize these objectives as to be able to conduct the corresponding analyses in an automatic fashion using the deductive power of established approaches for model validation and verification. Finally, we discuss how the resulting methodology can actually be applied and demonstrate its potential for elaborated analyses of frame conditions.

Paper Nr: 37
Title:

Static Analysis of Conformance Preserving Model Transformation Rules

Authors:

Fazle Rabbi, Lars Michael Kristensen and Yngve Lamo

Abstract: Model transformation is a core element in model driven software engineering and is used for several purposes, including model migration, model synthesis, and code generation. Application of conformance preserving transformation rules guarantee that produced output models will conform to its underlying metamodel. Conformance persevering rules are therefore important in order to ensure the formal correctness of transformations. However, to determine if a rule is conformance preserving requires sophisticated analysis techniques. The contribution of this paper is a new algorithm for checking conformance preserving rules with respect to a set of graph constraints and to prove the soundness of the algorithm. We apply our technique to homogeneous model transformations where input and output models must conform to the same meta-model. The algorithm relies on locality of a constrained graph to reduce the computational cost. We show that the performance of our algorithm depends on the complexity of the graph constraints and model transformation rules, but that it is independent of the size of the input model.

Paper Nr: 40
Title:

Model-Based Development of Self-Adaptive Autonomous Vehicles using the SMARDT Methodology

Authors:

Steffen Hillemacher, Stefan Kriebel, Evgeny Kusmenko, Mike Lorang, Bernhard Rumpe, Albi Sema, Georg Strobl and Michael von Wenckstern

Abstract: Cyber-physical systems are deeply intertwined with their corresponding environment through sensors and actuators. To avoid severe accidents with surrounding objects, testing the the behavior of such systems is crucial. Therefore, this paper presents the novel SMARDT (Specification Methodology Applicable to Requirements, Design, and Testing) approach to enable automated test generation based on the requirement specification and design models formalized in SysML. This paper presents and applies the novel SMARDT methodology to develop a self-adaptive software architecture dealing with controlling, planning, environment understanding, and parameter tuning. To formalize our architecture we employ a recently introduced homogeneous model-driven approach for component and connector languages integrating features indispensable in the cyber-physical systems domain. In a compelling case study we show the model driven design of a self-adaptive vehicle robot based on a modular and extensible architecture.

Paper Nr: 44
Title:

Retrofitting Type-safe Interfaces into Template-based Code Generators

Authors:

Kai Adam, Arvid Butting, Oliver Kautz, Jerome Pfeiffer, Bernhard Rumpe and Andreas Wortmann

Abstract: Model-driven development leverages transformations to produce general-purpose programming language artifacts. Model-to-text (M2T) transformations facilitate ad-hoc transformation development by requiring less preparation than model-to-model transformations. Employing template engines is common for M2T trans- formations. However, the M2T transformation artifacts (templates) rarely provide interfaces to support their black-box integration. Instead, composing templates requires in-depth expertise of their internals to identify and pass the required arguments. This complicates their reuse, and, hence, code generator development. Where switching to more expressive template engines is not feasible, conceiving templates as models can alleviate these challenges. We present a method to retrofit type-safe signatures into templates, generate typed interfaces from these, and show how this can be utilized to compose independently developed templates for more efficient code generator engineering.

Paper Nr: 60
Title:

Defining Services and Service Orchestrators Acting on Shared Sensors and Actuators

Authors:

Rayhana Bouali Baghli, Elie Najm and Bruno Traverson

Abstract: In the context of the Internet of Things (IoT), it is necessary to design services that are loosely coupled to the objects on which they act. We call these loosely coupled services generic services. Based on a previous work that defines a three-levelled architecture for the IoT, we first propose a declarative approach to the design generic services for the IoT. Then, based on this declarative description, we define service orchestrators which are high level services that are able to manage access conflicts of services to connected objects. Next, we describe consistency rules to check validity of a generic service or an orchestrator. Finally, we illustrate our approach with use cases around services in a smart home.

Paper Nr: 84
Title:

Component-based Modeling in Umple

Authors:

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

Abstract: Modelling tools provide weak or no support for the rich semantics of composite structure, such as enforcing connection constraints and maintaining referential integrity. Tools that generate code from composite structure typically depend on excessive and complex internal class representations such as Actor or BasePort. In this paper, we present easy-to-comprehend syntax describing composite structure in Umple. We describe a novel protocol-free approach that dynamically extracts communication protocols as a way to ease component-based modelling, and lead to concise and optimized code generation. We outline Umple composite structure features, and the related code generation patterns that resolve difficulties around connections and the integrity of multiplicity constraints.

Short Papers
Paper Nr: 14
Title:

Refinements and Structural Decompositions in Generated Code

Authors:

Georg Hinkel, Kiana Busch and Robert Heinrich

Abstract: Todays systems are often represented by abstract domain models to cope with an increased complexity. To both ensure suitable analyses and validity checks, it is desirable to model the system in multiple levels of abstraction simultaneously. Doing so, it is often desirable to model that one association is a refinement of another to avoid duplication of concepts. Existing approaches that support refinements request metamodelers to use new modeling paradigms or have less efficient model representations than commonly-used technologies such as EMF with Ecore. In this paper, we propose a non-invasive extension to support refinements and structural decompositions in Ecore-like meta-metamodels, show how these extension can be supported by code generation and show that the fulfillment of refinements can be guaranteed by the underlying type system.

Paper Nr: 27
Title:

Verifiable Parameterised Behaviour Models - For Robotic and Embedded Systems

Authors:

Vladimir Estivill-Castro and René Hexel

Abstract: Logic-labeled Finite-State Machines (LLFSMs) are Communicating Extended Finite State Machines that execute concurrently but with a predefined sequential schedule. This capacity has enabled effective formal verification. Moreover, LLFSMs are very powerful tools for Model-Driven Software Engineering of the behaviour of robotic and embedded systems. Although existing schedulers are capable of executing several instances of the same model, the challenge is to provide mechanisms for creating parameterised models akin to function calls. Since recent task planning algorithms can synthesise behaviours as LLFSMs with parameters and recursion, it becomes necessary to have a useful operational tool that produces compiled executables for such behaviours. Moreover, parameterisation allows replication of generic system components, reducing overall design complexity. We produce safe mechanisms to set actual and formal parameters for multiple, concurrent instances of the same behaviour. We achieve the parameterisation of behaviour models analogous to a procedural abstraction and discuss its advantages and disadvantages on formal verification.

Paper Nr: 35
Title:

Challenges and Opportunities of Modularizing Textual Domain-Specific Languages

Authors:

Christoph Rieger, Martin Westerkamp and Herbert Kuchen

Abstract: Over time, domain-specific languages (DSL) tend to grow beyond the initial scope in order to provide new features. In addition, many fundamental language concepts are reimplemented over and over again. This raises questions regarding opportunities of DSL modularization for improving software quality and fostering language reuse – similar to challenges traditional programming languages face but further complicated by the surrounding editing infrastructure and model transformations. Mature frameworks for developing textual DSLs such as Xtext provide a wealth of features but have only recently considered support for language composition. We therefore perform a case study on a large-scale DSL for model-driven development of mobile applications called MD2, and review the current state of DSL composition techniques. Subsequently, challenges and advantages of modularizing MD2 are discussed and generalized recommendations are provided.

Paper Nr: 39
Title:

Model Driven Architecture based Testing Tool based on Architecture Views

Authors:

Burak Uzun and Bedir Tekinerdogan

Abstract: Model Driven Architecture Based Testing (MDABT) is a testing approach exploiting the knowledge in the design phase to test the software system. MBT can use different representations of the system to generate testing procedures for different aspects of the software systems. The overall objective of this paper is to present a model-driven architecture based testing tool framework whereby the adopted models represent models of the architecture. Based on the model-based testing approach we propose the MDABT process and the corresponding tool. The tool has been implemented using the Eclipse Epsilon Framework. We illustrate the MDABT tool framework for deriving test cases from different architecture views.

Paper Nr: 41
Title:

Clone Detection for Ecore Metamodels using N-grams

Authors:

Önder Babur

Abstract: Increasing model-driven engineering use leads to an abundance of models and metamodels in academic and industrial practice. A key technique for the management and maintenance of those artefacts is model clone detection, where highly similar (meta-)models and (meta-)model fragments are mined from a possibly large amount of data. In this paper we extend the SAMOS framework (Statistical Analysis of MOdelS) to clone detection on Ecore metamodels, using the framework’s n-gram feature extraction, vector space model and clustering capabilities. We perform a case analysis on Ecore metamodels obtained by applying an exhaustive set of single mutations to assess the precision/sensitivity of our technique with respect to various types of mutations. Using mutation analysis, we also briefly evaluate MACH, a comparable UML clone detection tool.

Paper Nr: 42
Title:

Translating Multi-device Task Models to State Machines

Authors:

Andreas Wagner and Christian Prehofer

Abstract: This paper presents an approach for translating multi-device task models to a distributed execution model based on state machines. We consider an expressive extension to ConcurTaskTrees, called multi-device ConcurTaskTrees (MCTTs) as a modeling language for distributed multi-device applications. We use the device labeling operators Any and All, which specify if user interactions at runtime shall take place on one or all of a set of devices and extend the translation algorithm for “classical” CTT operators with translation rules for these multi-device operators in a distributed setting. Our algorithm exploits concurrent and hierarchical state machines for the execution and the concept of partial state machines during the translation.

Paper Nr: 43
Title:

Can Abstraction Be Taught? Refactoring-based Abstraction Learning

Authors:

Naoyasu Ubayashi, Yasutaka Kamei and Ryosuke Sato

Abstract: Can the notion of abstraction be taught to students? It is a very difficult question. Abstraction plays an important role in software development. This paper shows that refactoring is effective for students to learn the notion of abstraction. We focus on design abstraction, because it is one of the crucial parts in teaching the essence of software engineering. To explore for a well-balanced separation of concerns between design and code, it is not avoidable to go back and forth between them. To help a student find an appropriate abstraction level, we introduce abstraction-aware refactoring patterns consisting of MoveM2C (Move concerns from Model to Code) and CopyC2M (Copy concerns from Code to Model). The patterns enable a student to refine abstraction while preserving not only external functionality but also traceability between design and code.

Paper Nr: 48
Title:

Exploring DSL Evolutionary Patterns in Practice - A Study of DSL Evolution in a Large-scale Industrial DSL Repository

Authors:

Josh G. M. Mengerink, Bram van der Sanden, Bram C. M. Cappers, Alexander Serebrenik, Ramon R. H. Schiffelers and Mark G. J. van den Brand

Abstract: Model-driven engineering is used in the design of systems to (a.o.) enable analysis early in the design process. For instance, by using domain-specific languages, enabling engineers to model systems in terms of their domain, rather then encoding them into general purpose modeling languages. Domain-specific languages, like classical software, evolve over time. When domain languages evolve, they may trigger co-evolution of models, model-to-model transformations, editors (both graphical and textual), and other artifacts that depend on the domain-specific language. This co-evolution can be tedious and very costly. In literature, various approaches are proposed towards automated co-evolution. However, these approaches do not reach full automation. Several other studies have shown that there are theoretical limitations to the level of automation that can be achieved in certain scenarios. For several scenarios full automation can never be achieved. We wish to gain insight to which extent practically occurring scenarios can be automated. To gain this insight, in this paper, we investigate on a large-scale industrial repository, which (co-)evolutionary scenarios occur in practice, and compare them with the various scenarios and their theoretical automatability. We then assess whether practically occurring scenarios can be fully automated.

Paper Nr: 55
Title:

A Model-driven Approach for Generating RESTful Web Services in Single-Page Applications

Authors:

Adrian Hernandez-Mendez, Niklas Scholz and Florian Matthes

Abstract: Modern Single-Page Applications (SPA) use data from multiple Web services to support essential process in the enterprises. By using data from several Web services, the SPA changed their architecture from a one-to-one communication between client and server to an application using information from multiple servers using RESTfuls APIs in a microservice architecture. In this paper, we present a model-driven approach for the consumption of RESTful Web services in SPA. We introduce a Query Service meta-model and provide a tool to semi-automatically generate an SPA based on our reference architecture. The proposed approach was evaluated by using the tool for the development of an example application in the context of a research project with large German corporation in the domain of software architecture. The main limitation of the tool is the lack of support for the round-trip engineering functionality. However, the created Web service handles the access to APIs and reduces the complexity of the SPA due to the shift of responsibility away from the client.

Paper Nr: 56
Title:

Automatic Transformation from Ecore Metamodels towards Gallina Inductive Types

Authors:

Jérémy Buisson and Seidali Rehab

Abstract: When engineering a language (and its compiler), it is convenient to use widespread and easy-to-use MDE frameworks like Xtext that automatically generate a compiler infrastructure, and even a full-featured IDE. At the same time, a formal workbench such as a proof assistant is helpful to ensure the language specification is sound. Unfortunately, the two technical spaces hardly integrate. In this paper, we propose a transformation from Ecore's metametamodel to Coq's language named Gallina/Vernacular. The structural fragment of Ecore is fully handled. At the cost of not being bijective, our transformation has relaxed constraints over the input metamodel, in comparison to previous state of the art. To validate, we have used the proposed transformation with a complete and representative test suite, as well as a proof-carrying code type checker.

Paper Nr: 80
Title:

Towards Systematic and Automatic Handling of Execution Traces Associated with Scenario-based Models

Authors:

Joel Greenyer, Daniel Gritzner, David Harel and Assaf Marron

Abstract: Scenario-based specification approaches offer system engineering advantages with their intuitiveness, executability, and amenability to formal verification and synthesis. However, many engineering tasks such as debugging or maintenance are still far from trivial even when using such specifications. Specifically, it is hard to find out why a complex system behaves as it does, or how it would behave under certain conditions. Here, we present work in progress towards the (semi-)automatic analysis of event traces emanating from simulation runs and actual executions. These traces may be large, yet developers are often interested only in specific properties thereof, like is any specification property violated? are particular properties demonstrated? is there a smaller sub-sequence of events that violates or demonstrates the same properties? which trace properties are common to multiple traces and which are unique? etc. Our approach includes automatic techniques for discovering and distilling relevant properties of traces, analyzing properties of sets of traces, using (sets of) execution traces for understanding specified and actual system behavior and problems therein, planning system enhancement and repair, and more. Our work leverages and extends existing work on trace summarization, formal methods for model analysis, specification mining from execution traces, and others, in the context of scenario-based specifications. A key guiding perspective for this research is that interesting properties of a trace often can be associated with one or very few concise scenarios, depicting desired or forbidden behavior, which are already in the specification, or should be added to it.

Paper Nr: 81
Title:

Towards Better Document to Model Synchronisation: Experimentations with a Proposed Architecture

Authors:

Arnaud Michot, Christophe Ponsard and Quentin Boucher

Abstract: The Model Based Engineering approach is centred around the use of a model repository and a modelling tool. A drawback of the approach is that the evolution of derived documents or other artefacts requires to go back to the model. This process involves tracing the source element back in the model editor before triggering updates. This can reveal quite inefficient and even cause user rejection. This paper presents a reusable architecture including a back channel from a document to the related model. It efficiently supports the locate operation of model elements from the document, model updates from the document (including in-place text editing, e.g. to fix typos inside a description), and even concept creation from a text document. We also report on our experience in implementing this architecture in two modelling tools: the Objectiver goal-oriented requirements engineering tool and the Eclipse Modelling Framework, both with mainstream commercial and Open Source text processors.

Paper Nr: 89
Title:

Model-guided Security Analysis of Interconnected Embedded Systems

Authors:

Yasamin Mahmoodi, Sebastian Reiter, Alexander Viehl, Oliver Bringmann and Wolfgang Rosenstiel

Abstract: Software-intensive and networked embedded systems implement more and more security critical tasks. The following paper presents a framework to support security analysis along the design process using virtual prototypes (VPs). VPs describe the interconnection between different system components, include actual application codes and even integrate existing physical prototypes. These enable the user to detect structural security flaws, implementation flaws and even hardware-based security problems. Benefits of using VPs are the early availability in the design process and the fact that VPs are based on software, therefore established security analysis methods for software can be applied. This paper provides a methodology and tooling support to apply VP in the context of security analyses. Especially the integration in a model-driven design (MDD) process is highlighted. A proposed security UML profile as well as code generation ease the VP-based analysis.

Posters
Paper Nr: 22
Title:

Managing Variability in Models and Derived Artefacts in Model-driven Software Product Lines

Authors:

Thomas Buchmann and Sandra Greiner

Abstract: Software product line engineering aims at automatically deriving a family of software products from a common platform. Model-driven software engineering emphasizes using models as primary development artefacts. In many cases, the static structure of a software system can be automatically generated from static models such as class diagrams. However, hand-written source code is still necessary, either for specifying method bodies or for integrating the generated code with already existing artefacts or frameworks. This fact causes problems when developing software product lines in a model-driven way: Variability information needs to be kept consistent over a series of heterogeneous artefacts, including models and generated as well as hand-written source code. In this paper, we present a concept and the corresponding technical solution, which allows for managing variability in models and corresponding derived artefacts. We demonstrate the feasibility of our approach with the help of a concrete use case in the context of models and hand-written source code fragments.

Paper Nr: 23
Title:

BXtend - A Framework for (Bidirectional) Incremental Model Transformations

Authors:

Thomas Buchmann

Abstract: Model transformations constitute the core essence of model-driven software development (MDSD) – a software engineering discipline, which gained more and more attention during the last decade. While technology for unidirectional batch transformations seems to be fairly well developed, tool support for bidirectional and incremental transformations is still restricted. Results obtained with case studies carried out with popular bidirectional approaches motivated us to set up our own light-weight framework for bidirectional and incremental model transformations based on the Xtend programming language. Our approach provides several advantages, as it reduces the cognitive complexity for transformation developers, and allows for a greater flexibility in transformation specifications by providing procedural language constructs. In addition, it provides a higher expressive power and allows for compact specifications at the same time.

Paper Nr: 24
Title:

Implementing Contract-based Software Architectures in Java: The Structural, Behavioural, and Interaction Design Decisions

Authors:

Mert Ozkaya

Abstract: Architectural languages (ALs) have been so actively researched since the nineties and this leads to many ALs with different capabilities that have been proposed each day. However, most of the ALs ignore the specifications of the structural, behavioural, and interaction design decisions and do not support their analysis and development. The ALs that do support suffer from the process algebra based notation sets that practitioners do not prefer to work with. This issue is tackled in the paper by extending the Design-by-Contract based architectural language called XCD that supports the contractual specifications of the structural, behavioural, and interaction design decisions about software systems and their formal analysis. XCD is extended with a development support in Java so as to transform the contractual specifications in XCD into a complete Java program that considers all the structural, behavioural, and interaction decisions specified. So, practitioners will be able to specify non-algebraic, contractual specifications in XCD, formally analyse them, and produce the Java source-code that reflects the specified architecture completely and consistently. The produced Java code can also be tested for incompleteness and wrong use of component services automatically.

Paper Nr: 26
Title:

Analysis of the Evolution of the UML Metamodel

Authors:

Zhiyi Ma, Huihong He, Jinyang Liu and Xiao He

Abstract: UML has been widely used for modeling applications and it changes continuously. In this situation, it is reasonable to analyze its evolution. This paper presents an approach to analyzing the evolution of the UML metamodel by using complex network and information entropy technologies. The approach can provide insight into the constructive mechanism and future trends of UML, and potentially form the basis for eliciting improved or novel laws of UML evolution. The study is a contribution for analyzing the evolution of not only the UML metamodel but also other metamodels like the UML metamodel.

Paper Nr: 31
Title:

Supporting Simulation Experiments with Megamodeling

Authors:

Sema Çam, Orçun Dayıbaş, Bilge K. Görür, Halit Oğuztüzün, Levent Yilmaz, Sritika Chakladar, Kyle Doud, Alice E. Smith and Alejandro Teran-Somohano

Abstract: Recent developments in computational science and engineering allow a great deal of experimental work to be conducted through computer simulation. In a simulation experiment, a model of the phenomena to be studied is run in a computing environment under varying model and environment settings. As models are adjusted to experimental procedures and execution environments, variations arise. Models also evolve in time. Thus, models must be managed. We propose to bring Global Model Management (GMM) to bear on simulation experiment management by using techniques and tools from megamodeling. The proposed approach will facilitate model management tasks by providing an interface to query the model repository, relate models with each other, and apply model transformations from/to simulation models. Our proposed Megamodel for Simulation Experiments is based on SED-ML (Simulation Experiment Description Markup Language).

Paper Nr: 34
Title:

Cloud Security and Privacy Metamodel - Metamodel for Security and Privacy Knowledge in Cloud Services

Authors:

Tian Xia, Hironori Washizaki, Takehisa Kato, Haruhiko Kaiya, Shinpei Ogata, Eduardo B. Fernandez, Hideyuki Kanuka, Masayuki Yoshino, Dan Yamamoto, Takao Okubo, Nobukazu Yoshioka and Atsuo Hazeyama

Abstract: Security and privacy are important in cloud services. Numerous security and privacy patterns as well as non-pattern-based knowledge such as practices and principles exist in cloud services. Selecting and combining the appropriate knowledge is difficult due to numerous options and the nature of the layered cloud stack. Herein we propose a metamodel called the Cloud Security and Privacy Metamodel (CSPM) to handle security and privacy in cloud service development and operations. CSPM can classify and support existing cloud security and privacy patterns and practices in a consistent and uniform manner. Moreover, we propose a security and privacy aware process to develop cloud system utilizing CSPM. Several case studies verify the effectiveness and usability of our approach. As a result, we confirmed effectiveness and usability of CSPM, as well as some possible future work.

Paper Nr: 50
Title:

Ontology then Agentology: A Finer Grained Framework for Enterprise Modelling

Authors:

Chris Partridge, Sergio de Cesare, Andrew Mitchell, Ana León, Frederik Gailly and Mesbah Khan

Abstract: Data integration of enterprise systems typically involves combining heterogeneous data residing in different sources into a unified, homogeneous whole. This heterogeneity takes many forms and there are all sorts of significant practical and theoretical challenges to managing this, particularly at the semantic level. In this paper, we consider a type of semantic heterogeneity that is common in Model Driven Architecture (MDA) Computation Independent Models (CIM); one that arises due to the data’s dependence upon the system it resides in. There seems to be no relevant work on this topic in Conceptual Modelling, so we draw upon research done in philosophy and linguistics on formalizing pure indexicals – ‘I’, ‘here’ and ‘now’ – also known as de se (Latin ‘of oneself’) or the deitic centre. This reveals firstly that the core dependency is essential when the system is agentive and the rest of the dependency can be designed away. In the context of MDA, this suggests a natural architectural layering; where a new concern ‘system dependence’ is introduced and used to divide the CIM model into two parts; a system independent ontology model and a system dependent agentology model. We also show how this dependence complicates the integration process – but, interestingly, not reuse in the same context. We explain how this complication usually provides good pragmatic reasons for maximizing the ontology content in an ‘Ontology First’, or ‘Ontology then Agentology’ approach.

Paper Nr: 51
Title:

A C++ Implementation of UML Subsets and Unions for MDE

Authors:

Francesco Bedini, Ralph Maschotta, Alexander Wichmann and Armin Zimmermann

Abstract: This paper shows and discusses the realization of advanced data structures used in the UML specification (namely subsets, unions, and subset-unions) for a C++ execution engine. Those data structures have been realized thanks to the use of variadic templates, which were first introduced in C++11. Thanks to those templates which allow to take as parameters a non-fixed number of elements in an elegant manner, it has been possible to automatically generate from the Ecore and UML ecore models type-safe data structures which avoid elements being duplicated or the generation of additional lists during run-time. A performance analysis is presented to show how our implementation behaves compared to the other possible approaches.

Paper Nr: 63
Title:

A New Approach for Reflection of Code Modifications to Model in Synchronization of Architecture Design Model and Code

Authors:

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

Abstract: Model-Driven Engineering (MDE) increases the abstraction level, thus facilitates the design of complex systems. It is possible to create an executable system from a model enriched with detailed behavior specifications. But the graphical modeling of some system aspects is likely less efficient compared to writing code in a programming language. For method signatures, textual editing includes a few lines of text, whereas modeling requires the separate addition of methods along with their parameters. Therefore, we propose to develop systems by combining the strength of graphical modeling with programming languages by allowing a developer to make changes in either notation and synchronize the result with the other one, respectively. Synchronization between model and code is already supported by existing tools, but often restricted to structural elements that have a 1-1 mapping. The synchronization of additional modeling aspects from the code, notably component based modeling in UML and behavior in form of state-machines, is not supported by the state-of-the-art. In order to enable this synchronization, it is important to reduce the abstraction gap and assure a 1-1 mapping if possible. Our proposition is to perform the synchronization with an extended programming language that provides additional language elements for some UML elements, notably those that do not already exist in object-oriented programming languages. This extension uses built-in language facilities, in case of C++ templates and preprocessor macros, and a design pattern that adds a shadow implementation.

Paper Nr: 71
Title:

Self-describing Operations for Multi-level Meta-modeling

Authors:

Dániel Urbán, Zoltán Theisz and Gergely Mezei

Abstract: Any meta-modeling discipline, similar to programming languages, will, sooner or later, feel the need for some operational language in order to express constraints for model validation and/or action semantics for executable modeling. Multi-level meta-modeling is no exception in this regard. However, it does provide the facility to formalize the operation language within the meta-modeling framework, thus the language syntax and semantics fits perfectly well the intended need of the modeling environment. Moreover, if the modeling framework is flexible enough in the principles, the model validation can be specified and also applied to the operation language as well. In this paper, we shortly introduce such a modeling formalism, DMLA, and then describe in relative detail the design and the current realization of its operation language, DMLAScript, which enables the multi-level meta-modeling framework to effectively tackle realistic domain models.

Paper Nr: 75
Title:

A Combination of V Development Life Cycle and Model-based Testing to Deal with Software System Evolution Issues

Authors:

Imane Essebaa and Salima Chantit

Abstract: Manage Testing is one of the most important and difficult phases in the development process. Indeed, it is a decisive step before deploying a product which aims to verify and validate whether the developed product satisfies customer requirements. This step becomes more and more difficult when we face evolutionary system requirement. Several works and approaches were proposed to deal with this issue but they do not describe any approach to well manage test phase in evolutionary software system. It is in this context that this paper proposes a new approach that resolves the problem of managing tests even in a system with evolutionary requirements. As our works are focused on Modeling Driven Development represented by its variant Model Driven Architecture, we will focus in this work on automating test generation from well known models as Model-Based Testing combined with development life cycle to deal with system evolutions. For this first work, we focus on V life cycle since it specifies different types of test needed to well test a system. In order to illustrate concepts used in our approach, we will present their application in a RentalCarAgency applications.

Paper Nr: 82
Title:

Concurrent Programming using Umple

Authors:

Mahmoud Husseini Orabi, Ahmed Husseini Orabi and Timothy C Lethbridge

Abstract: UML standards lack systematic solutions that can handle concurrency and time constructs in a single unified notation. In this paper, we integrate concurrency as a part of Umple, a combined modelling and programming language. Our extensions can help ease component-based development of real-time, distributed, and embedded applications. The work, which is based on an extended implementation of active object, enables better validation of systems, and improves usability from the developer’s perspective. We describe the syntax and semantics of our Umple extensions, and also show how the constructs are transformed into C++. After that, we evaluate our work qualitatively, by comparing Umple with other specifications that focus on time as key; we show that Umple gives more flexibility than UML and MARTE. We also evaluate our work quantitatively using LOC and cyclomatic complexity metrics, showing that a developer would have to write many fewer lines of code when using Umple than when programming directly in C++.