MODELSWARD 2015 Abstracts


Area 1 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 1
Title:

Towards the Integration of Model-Driven Engineering, Software Product Line Engineering, and Software Configuration Management

Authors:

Felix Schwägerl, Thomas Buchmann, Sabrina Uhrig and Bernhard Westfechtel

Abstract: Model-Driven Software Engineering (MDSE), Software Product Line Engineering (SPLE) and Software Configuration Management (SCM) have been established as independent disciplines to ease different aspects of software development. The usage of models as high-level abstractions promises to increase productivity, while software product lines manage variability within a family of similar software products; software configuration management systems manage evolution and support collaborative development. In this paper, we explore the state of the art regarding the pairwise combinations MDSE/SPLE, SPLE/SCM, and MDSE/SCM and show that an integrated solution combining all three disciplines is missing. We present a conceptual framework to integrate MDSE, SPLE and SCM uniformly based on a filtered editing model. The framework implies a number of advantages, namely unconstrained variability, a reduction of cognitive complexity, improved consistency, tool independence, and a higher level of automation. Our formalism is based on a uniform versioning model for temporal, cooperative, and logical versioning of models. By an example, we show the feasibility of our approach.

Paper Nr: 4
Title:

Integration of Heterogeneous Modeling Languages via Extensible and Composable Language Components

Authors:

Arne Haber, Markus Look, Antonio Navarro Perez, Pedram Mir Seyed Nazari, Bernhard Rumpe, Steven Völkel and Andreas Wortmann

Abstract: Effective model-driven engineering of complex systems requires to appropriately describe different specific system aspects. To this end, efficient integration of different heterogeneous modeling languages is essential. Modeling language integaration is onerous and requires in-depth conceptual and technical knowledge and effort. Traditional modeling lanugage integration approches require language engineers to compose monolithic language aggregates for a specific task or project. Adapting these aggregates to different contexts requires vast effort and makes these hardly reusable. This contribution presents a method for the engineering of grammar-based language components that can be independently developed, are syntactically composable, and ultimately reusable. To this end, it introduces the concepts of language aggregation, language embedding, and language inheritance, as well as their realization in the language workbench MontiCore. The result is a generalizable, systematic, and efficient syntax-oriented composition of languages that allows the agile employment of modeling languages efficiently tailored for individual software projects.

Area 2 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 6
Title:

Evolving Legacy Model Transformations to Aggregate Non Functional Requirements of the Domain

Authors:

Joseba A. Agirre, Goiuria Sagardui and Leire Etxeberria

Abstract: The use of Model Driven Development (MDD) is increasing in industry. When a Non Functional Requirement (NFR) not considered in the development must be added metamodels, models and also transformations are affected. Tasks for defining and maintaining model transformation rules can be complex in MDD. Model Transformation By Example (MTBE) approaches have been proposed to ease the development of transformation rules. In this paper an approach based on MTBE to derive the adaptation operations that must be implemented in a legacy model transformation when a NFR appears is presented. The approach derives semi-automatically the model transformations using execution traceability data and models differences. An example where access control property is integrated on a MDD system is introduced to demonstrate the usefulness of the tool to evolve model transformations.

Paper Nr: 11
Title:

SysML Modeling for Embedded Systems Design Optimization - A Case Study

Authors:

Patrick Leserf, Pierre de Saqui-Sannes, Jérôme Hugues and Khaled Chaaban

Abstract: Model-Based Systems Engineering (MBSE) with the SysML language allows the designer to include requirement capture and design representation in a single model. This paper proposes a methodology to obtain the best design alternative, from a SysML design, by using multi-objective optimization techniques. A SysML model is extended with stereotypes, objective functions, variability and constraints. Then an integer representation of the problem can be generated and solved as a constraint satisfaction problem (CSP). The paper illustrates our methodology using an Embedded Cognitive Safety System (ECSS) design. From a component repository and redundancy alternatives, the best design alternatives are generated, to minimize the total cost and maximize the estimated system reliability.

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 15
Title:

Specification of Adaptable Model Migrations

Authors:

Paola Vallejo, Mickaël Kerboeuf and Jean-Philippe Babau

Abstract: This paper puts the focus on adaptable model migrations. A dedicated formalism is introduced to combine automatically-generated migrations with custom-made migrations. To illustrate this issue and the approach we suggest to address it, a prototype engine is presented. Then, the prototype is applied on a case study. The prototype processes the migration specifications that have been automatically generated and then customized. The case study consists of the reuse of a mapping tool, in order to change highlighted places. During the reuse process the migration specification is customized in order to produce different migrated models.

Paper Nr: 17
Title:

Architectural View Driven Model Transformations for Supporting the Lifecycle of Parallel Applications

Authors:

Ethem Arkin and Bedir Tekinerdogan

Abstract: Two important trends can be identified in parallel computing. First of all, the scale of parallel computing platforms is rapidly increasing. Secondly, the complexity and variety of current software systems requires to consider the parallelization of application modules beyond algorithms. These two trends have led to a complexity that is not scalable and tractable anymore for manual processing, and therefore automated support is required to design and implement parallel applications. In this context, we present a model-driven transformation chain for supporting the automation of the lifecycle of parallel computing applications. The model-driven transformation chain adopts metamodels that are derived from architectural viewpoints. The transformation chain is defined as a logical sequence consisting of model-to-model transformations. We present the tool support that implements the metamodels and transformations.

Paper Nr: 21
Title:

A Toolset for Simulink - Improving Software Engineering Practices in Development with Simulink

Authors:

Vera Pantelic, Steven Postma, Mark Lawford, Alexandre Korobkine, Bennett Mackenzie, Jeff Ong and Marc Bender

Abstract: This paper presents a set of tools that provide automatic support for application of some of the traditional software engineering practices when developing with Simulink. The tools are the: Signature Tool, Reach/Coreach Tool, Data Store Push-Down Tool, and Auto Layout Tool. The Signature Tool extracts the interface of a Simulink subsystem, identifying the subsystem’s explicit, and implicit data flow mechanisms, empowering developers to use the implicit mechanisms more effectively. The Reach/Coreach Tool identifies data and control flow dependencies in a Simulink model and uses the information for model slicing. The view of dependencies offered by the tool significantly eases the comprehension of large models. The dependencies can also serve as indicators of alternative designs, and facilitate more effective testing and verification. The Data Store Push-Down Tool restricts the scope of Simulink’s data stores thereby providing improved encapsulation, and increasing modularity. Finally, the Auto Layout Tool significantly decreases the manual effort developers spend in achieving proper layout of models during design and refactoring, and can be used by automated refactoring and transformation tools.

Paper Nr: 27
Title:

Model Query Translator - A Model-level Query Approach for Large-scale Models

Authors:

Xabier De Carlos, Goiuria Sagardui, Aitor Murguzur, Salvador Trujillo and Xabier Mendialdua

Abstract: Persisting and querying models larger than a few tens of megabytes using XMI introduces a significant time and memory footprint overhead to MDD workflows. In this paper, we present an approach that attempts to address this issue using an embedded relational database as an alternative persistence layer for EMF models, and runtime translation of OCL-like expressions for efficiently querying such models. We have performed an empirical study of the approach using a set of large-scale reverse engineered models and queries from the Grabats 2009 Reverse Engineering Contest. Main contribution of this paper is the Model Query Translator, an approach that translates (and executes) at runtime queries from model-level (EOL) to persistence-level (SQL).

Paper Nr: 29
Title:

A Comparison of Mechanisms for Integrating Handwritten and Generated Code for Object-Oriented Programming Languages

Authors:

Timo Greifenberg, Katrin Hölldobler, Carsten Kolassa, Markus Look, Pedram Mir Seyed Nazari, Klaus Müller, Antonio Navarro Perez, Dimitri Plotnikov, Dirk Reiss, Alexander Roth, Bernhard Rumpe, Martin Schindler and Andreas Wortmann

Abstract: Code generation from models is a core activity in model-driven development (MDD). For complex systems it is usually impossible to generate the entire software system from models alone. Thus, MDD requires mechanisms for integrating generated and handwritten code. Applying such mechanisms without considering their effects can cause issues in projects with many model and code artifacts, where a sound integration for generated and handwritten code is necessary. We provide an overview of mechanisms for integrating generated and handwritten code for object-oriented languages. In addition to that, we define and apply criteria to compare these mechanisms. The results are intended to help MDD tool developers in choosing an appropriate integration mechanism.

Paper Nr: 33
Title:

A Formalisation of Analysis-based Model Migration

Authors:

Ingrid Chieh Yu and Henning Berg

Abstract: Supporting adaptation of metamodels is essential for realising Model-Driven Engineering. However, adapting and changing metamodels impact other artefacts of the metamodelling ecosystem. In particular, conformant models will no longer be valid instances of their changed metamodel. This gives rise to co-evolution issues where metamodels and models are no longer synchronised. This is critical as systems become inconsistent. A typical approach for re-establishing conformance is to manually craft transformations which update existing models for the new metamodel variant. In this paper we present an analysis-based approach that addresses this concern. The approach enables an arbitrary number of metamodels to evolve based on an adaptation strategy. During analysis we accumulate information required to automatically transform existing models to ensure conformance. We formalise the approach and prove model conformance.

Paper Nr: 34
Title:

Ubtl - UML Testing Profile based Testing Language

Authors:

Johannes Iber, Nermin Kajtazovic, Andrea Höller, Tobias Rauter and Christian Kreiner

Abstract: The continuous increase of software complexity is one of the major problems associated with the development of today’s complex technical systems. In particular, for safety-critical systems, which usually require to be thoroughly verified and validated, managing such a complexity is of high importance. To this end, industry is utilizing Model-Driven Development (MDD) in many aspects of systems engineering, including verification and validation activities. Until now many specifications and standards have been released by the MDD community to support those activities by putting models in focus. The general problem is, however, that applying those specifications is often difficult, since they comprise a broader scope than usually required to solve specific problems. In this paper we propose a domain-specific language (DSL) that allows to specify tests from the UML Testing Profile (UTP). The main contribution is that only particular aspects of UTP are captured, thereby allowing the MDD process to be narrowed to specific needs, such as supporting code generation facilities for certain types of tests or even specific statements in tests. In the end we show the application of the DSL using a simple example within a MDD process, and we report on performance of that process.

Paper Nr: 40
Title:

Towards Non-intrusive Composition of Executable Models

Authors:

Henning Berg and Birger Møller-Pedersen

Abstract: An essential operation in model-driven engineering is composition of models and their metamodels. There exist several mechanisms for model composition. However, most of these only consider composition of either models or metamodels and not both kinds of models simultaneously, and do not address how the composition impacts modelling artefacts like editors, transformations and semantics. Moreover, model composition mechanisms typically deal with model structure and do not consider operational semantics. In this paper, we discuss a novel approach for the composition of both models and metamodels in a virtually non-intrusive manner. We achieve this by utilising a placeholder mechanism where classes in one metamodel may represent classes of another. The ideas presented have been validated by the construction of a framework. We will illustrate how non-intrusive composition allows linking the operational semantics of different languages without rendering existing modelling artefacts inconsistent. This increases the flexibility in how languages can be combined, and reduces the amount of necessary changes of tools and other modelling utilities.

Area 4 - Applications and Software Development

Full Papers
Paper Nr: 46
Title:

Model-Driven Engineering of a Railway Interlocking System

Authors:

Fabio Scippacercola, Roberto Pietrantuono, Stefano Russo and András Zentai

Abstract: Model-Driven Engineering (MDE) promises to enhance system development by reducing development time, and increasing productivity and quality. MDE is gaining popularity in several industry sectors, and is attractive also for critical systems where they can reduce efforts and costs for verification and validation (V&V), and can ease certification. Incorporating model-driven techniques into a legacy well-proven development cycle is not simply a matter of placing models and transformations in the design and implementation phases. We present the experience in the model-driven design and V&V of a safety-critical system in the railway domain, namely the Prolan Block, a railway interlocking system manufactured by the Hungarian company Prolan Co., required to be CENELEC SIL-4 compliant. The experience has been carried out in an industrial- academic partnership within the EU project CECRIS. We discuss the challenges and the lessons learnt in this pilot project of introducing MD design and testing techniques into the company’s traditional V-model process.

Area 5 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 55
Title:

Extending UML Templates towards Computability

Authors:

José Farinha and Pedro Ramos

Abstract: UML templates allow the specification of generic model elements that can be reproduced in domain models by means of the Bind relationship. Binding to a template encompasses the substitution of that template’s parameters by compatible domain elements. The requirement of compatibility, however, is checked over by UML in a very permissive way. As a consequence, binding to a template can result in badly-formed models and non-computable expressions. Such option in the design of UML was certainly intentional and meant to allow for richer semantics for the Bind relationship, as the specialization of the concept is advised at several points of the standard. This paper proposes one such specialization. One that guarantees well-formedness and computability for elements bound to a template. This is achieved by introducing the concept of Functional Conformance, which is imposed between every template’s parameter and its application domain substitute. Functional conformance is defined in terms of well-formedness rules, expressed as OCL constraints on top of OMG’s UML metamodel.

Paper Nr: 58
Title:

Software Architecture Design by Stepwise Model Transformations - A Comparative Case Study

Authors:

Fabian Gilson and Vincent Englebert

Abstract: Software architecture design is a critical task as lots of requirements can be taken into account on which many decisions can be made. The maintenance and evolution of resulting models often become tricky, even impracticable when their rationale is lost. In a previous work, we introduced a set of languages used in a transformation-centric design method meant to tackle this scattering of requirements and to facilitate further model evolutions. But, we did not provided a formal validation of our proposal yet. The present work depicts a comparative case study we conducted on a group of students. The participants were asked to develop an online book store in two phases, the second one simulating an evolution of the system. We evaluated the functional completeness of the created software as well as the traceability of design decisions and rationale. The participants were also asked to criticize the design method and language they used in a textual report and through a questionnaire. Even if the size of the case study is rather limited, it clearly highlighs the advantages of our approach regarding, among others, its expressiveness and decisions traceability.

Short Papers
Paper Nr: 2
Title:

Aggregate Callback - A Design Pattern for Flexible and Robust Runtime Model Building

Authors:

Gábor Kövesdán, Márk Asztalos and László Lengyel

Abstract: In modern software engineering environments, tools that use Domain-Specific Languages (DSLs) are often applied. The usual workflow of such tools is that the textual input written in the DSL is parsed and a semantic model is instantiated. This model is later passed to another software component that processes it, e.g. a model transformation, a code generator or a simulator. Building the semantic model inside the parser is often a complex task. The model must be built in such a way that the constraints of the problem domain are enforced so that the consistency of the output is guaranteed. This paper presents a design pattern, referred as Aggregate Callback that supports enforcing constraints in the model and thus helps creating correct models. We have found that the Aggregate Callback pattern is useful for tool developers that build models in their applications.

Paper Nr: 8
Title:

Towards World Model-based Test Generation in Autonomous Systems

Authors:

Anneliese Andrews, Mahmoud Abdelgawad and Ahmed Gario

Abstract: This paper describes a model-based test generation approach for testing autonomous systems interacting with their environment (i.e., world). Unlike other approaches that assume a static world with attributes and values, we present and test the world dynamically. We build the world model in two steps: a structural model that constructs environmental factors (i.e., actors) and a behavioral model that describes actors’ behaviors over a certain landscape (i.e., snippet). Abstract world behavioral test cases (AWBTCs) are then generated by covering the behavioral model using graph coverage criteria. The world model-based test generation technique (WMBTG) is used on an autonomous ground vehicle (AGV).

Paper Nr: 10
Title:

Model-based Approach for Implementation of Software Configuration Management Process

Authors:

Arturs Bartusevics and Leonids Novickis

Abstract: Software configuration management is a discipline that controls software evolution process. Nowadays this process is not only challenge to choose the best version control system o branching strategy for particular project. Together with source code management the following tasks should be solved: continuous integration, continuous delivery, release management, build management etc. Usually software development companies already have a set of tools to support mentioned processes. The main challenge is to adopt this solutions to new projects as soon as possible with minimum efforts of manual steps. The article provides new model-driven approach to increase reuse of existing solutions in configuration management area. In order to illustrate the approach, there were developed new meta-models that are purposed for development of different configuration management models in context of a model-driven approach. This article provides a simplified example to illustrate models and defines further researches.

Paper Nr: 12
Title:

Architecture Framework for Modeling the Deployment of Parallel Applications on Parallel Computing Platforms

Authors:

Bedir Tekinerdogan and Ethem Arkin

Abstract: To increase the computing performance the current trend is towards applying parallel computing in which the tasks are run in parallel on multiple nodes. Current approaches in parallel computing tend to focus on mapping parallel algorithms to parallel computing platforms. However, the complexity and variety of current software systems goes beyond the notion of algorithms only, and needs to consider the design from a broader application perspective that requires explicit design abstractions. For this purpose, we propose an architecture framework for modeling parallel applications to support the communication among the stakeholders, to reason about the design decisions and to support the analysis of the architectural design. The architecture framework consists of six coherent set of viewpoints which addresses different concerns in the design of parallel applications. The architecture framework is based on a metamodel that is derived after a thorough domain analysis on parallel computing. To support the architecture design process we have also developed the corresponding tool set that implements the architecture framework. The application of the architecture framework is illustrated for an order management application.

Paper Nr: 13
Title:

Towards Feature-driven Goal Fulfillment Analysis - A Feasibility Study

Authors:

Avjot Garcha Singh, Aida Omerovic, Franck Chauvel and Nicolas Ferry

Abstract: Design of a system architecture normally refers to a pre-defined goal. We consider the goal as the desired (functional or non-functional) aspect that is achieved by providing functionalities or mechanisms that support it. For example, a security goal is supported by a set of security mechanisms. However, there are often several ways towards (partially or completely) achieving a goal, which we refer to as design alternatives. Each design alternative is composed of a subset of the mechanisms needed. Some mechanisms are more important than others, and it is not obvious to what degree the different design alternatives fulfill the goal. It can moreover often be difficult to see what combinations of the design alternatives would result in maximum coverage of the goal. We propose an approach to modeling and analysis of the goals of a system. The approach supports specification of the goal, specification of the design alternatives, a quantification of the degree of fulfillment, as well as a quantification of the degree of overlap with respect to the goal fulfillment across design alternatives. We also propose a visual representation of the degrees of fulfillment and the degrees of overlap. We have evaluated the approach on a case study, and the initial results indicate its feasibility. This paper presents the approach and the evaluation results. It also summarizes experiences and suggestions for further improvements.

Paper Nr: 14
Title:

A MapReduce-based Approach for Finding Inexact Patterns in Large Graphs

Authors:

Péter Fehér, Márk Asztalos, Tamás Mészáros and Laszlo Lengyel

Abstract: Finding patterns in graphs is a fundamental problem in graph theory, and also a practical challenge during the analysis of big data sets. Inexact patterns may correspond to a set of possible exact graphs. Their use is important in many fields where pattern matching is applied (e.g. mining in social networks or criminal investigations). Based on previous work, this paper introduces a pattern specification language with special language features to express inexact patterns. We also show a MapReduce approach-based algorithm that is able to find matches. Our methods make it possible to define inexact patterns and to find the exact matches in large graphs efficiently.

Paper Nr: 16
Title:

Instantiation of Meta-models Constrained with OCL - A CSP Approach

Authors:

A. ferdjoukh, A. Baert, E. Bourreau, A. Chateau, R. Coletta and C. Nebut

Abstract: The automated generation of models that conform to a given meta-model is an important challenge in Model Driven Engineering, as well for model transformation testing, as for designing and exploring new meta-models. Amongst the main issues, we are mainly concerned by scalability, flexibility and a reasonable computing time. This paper presents an approach for model generation, which relies on Constraint Programming. After the translation of a meta-model into a CSP, our software generates models that conform to this meta-model, using a Constraint Solver. Our model also includes the most frequent types of OCL constraints. Since we are concerned by the relevance of the produced models, we describe a first attempt to improve them. We outperform the existing approaches from the mentioned point of view, and propose a configurable, easy-to-use and free-access tool, together with an on-line demonstrator.

Paper Nr: 18
Title:

Graphical Debugging of Distributed Applications - Using UML Object Diagrams to Visualize the State of Distributed Applications at Runtime

Authors:

Andreas Koch and Albert Zündorf

Abstract: While debugging is one of the most time consuming tasks software developers perform, the tool support, especially for distributed applications, is lacking according to many professional developers. The Visual Debugger is an approach to provide an easy-to-use tool which gives software developers an abstract view on the current state of their application in debugging sessions. While similar tools for non distributed applications already exist, the Visual Debugger addresses the more complex debugging scenarios in distributed applications. Therefore, several views with different levels of abstraction of the current state of an application are provided. Although the approach may be adapted to other object oriented programming languages, the current target of the Visual Debugger is languages running on the Java Virtual Machine with the focus on Java.

Area 6 - Applications and Software Development

Short Papers
Paper Nr: 25
Title:

Using a Domain-specific Modeling Language for Analyzing Harmonizing and Interfering Public and Private Sector Goals - A Scenario in the Context of Open Data for Weather Forecasting

Authors:

Sietse Overbeek and Marijn Janssen

Abstract: The opening of data by public organizations can result in innovations and new business models in the private sector. Yet, the public and private sectors may have different and sometimes interfering objectives. In this paper, we analyze the goals of an open data business model for weather forecasting using the multi-perspective goal modelling language GoalML. The public and private sectors partly share similar goals, but creating public value was found to be interfering (to some extent) with the private sector objective of making profit. One of the values of GoalML is that it clearly shows harmonizing and interfering goals. The interfering goals are one of the explanations for a slow adoption of open data. Mechanisms need to be developed to deal with them.

Area 7 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 26
Title:

Automated Model-based Testing Based on an Agnostic-platform Modeling Language

Authors:

Concepción Sanz, Alejandro Salas, Miguel de Miguel, Alejandro Alonso, Juan Antonio de la Puente and Clara Benac

Abstract: Currently multiple Domain Specific Languages (DSLs) are used for model-driven software development, in some specific domains. Software development methods, such as agile development, are test-centered, and their application in model-based frameworks requires model support for test development. We introduce a specific language to define generic test models, which can be automatically transformed into executable tests for particular testing platforms. The resulting test models represent the test plan for applications also built according to a model-based approach. The approach presented here includes some customisations for the application of the developed languages and transformation tools for some specific testing platforms. These languages and tools have been integrated with some specific DSL designed for software development.

Area 8 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 28
Title:

Knowledge Modeling in the Health Care Domain to Support Software Development & Maintenance

Authors:

Thomas Reichherzer, John Coffey, Bilal Gonen and Irad Gillett

Abstract: This article contains a description of a knowledge elicitation effort and representation pertaining to the modeling of conceptual knowledge in the health care field. The project has the goal of building a conceptual model of data in the Military Health System Data Repository, a large DoD/VA aggregation of databases that can be used in the implementation of software. The goal is to create a just-in-time conceptual model of the data to facilitate software development and foster software developer understanding of the domain.

Area 9 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 35
Title:

A Unified Formulation of Behavioral Semantics for SysML Models

Authors:

Christoph Hilken, Jan Peleska and Robert Wille

Abstract: In order to cope with the complexity of today’s system designs, higher levels of abstraction are considered. Modeling languages such as SysML provide adequate description means for an abstract specification of the structure and the behavior of a system to be implemented. Due to its sufficient degree of formality, SysML additionally allows for performing several automated test and verification tasks. For these tasks, however, a formal encoding of the behavioral model semantics is required; this is typically achieved by generating initial state conditions as well as the transition relation from the model. Since SysML provides a multitude of alternative or complementary notations, this poses a significant challenge to the development of corresponding tool support. In this paper, we therefore propose an alternative approach to the generation of transition relations: In a first step, a model-to-model transformation is applied which unifies the behavioral descriptions into one single notation, namely operations allocated in blocks and specified by pre- and post-conditions. Afterwards, only pre- and post-conditions as well as some auxiliary constraints for fixing semantic variation points need to be considered when generating the transition relation. The approach presented here has been evaluated in the development of industrial tools supporting bounded model checking and model-based test generation.

Paper Nr: 37
Title:

DCCSS - A Meta-model for Dynamic Clinical Checklist Support Systems

Authors:

Shan Nan, Pieter Van Gorp, Hendrikus H. M. Korsten, Uzay Kaymak, Richard Vdovjak, Xudong Lu and Huilong Duan

Abstract: Clinical safety checklists receive much research attention since they can reduce medical errors and improve patient safety. Computerized checklist support systems are also being developed actively. Such systems should individualize checklists based on information from the patient’s medical record while also considering the context of the clinical workflows. Unfortunately, the form definitions, database queries and workflow definitions related to dynamic checklists are too often hard-coded in the source code of the support systems. This increases the cognitive effort for the clinical stakeholders in the design process, it complicates the sharing of dynamic checklist definitions as well as the interoperability with other information systems. In this paper, we address these issues by contributing the DCCSS meta-model which enables the model-based development of dynamic checklist support systems. DCCSS was designed as an incremental extension of standard meta-models, which enables the reuse of generic model editors in a novel setting. In particular, DCCSS integrates the Business Process Model and Notation (BPMN) and the Guideline Interchange Format (GLIF), which represent best of breed languages for clinical workflow modeling and clinical rule modeling respectively. We also demonstrate one of the use cases where DCCSS has already been applied in a clinical setting.

Paper Nr: 39
Title:

A Survey of Object-Relational Transformation Patterns for High-performance UML-based Applications

Authors:

Nemanja Kojić and Dragan Milićev

Abstract: We outline a methodology for automatic and efficient object-relational mapping (ORM) in the context of model-driven development (MDD) of high-performance information systems specified with executable UML models. Although there are various approaches to performance tuning, we focus here on the persistence layer ̶ the relational database. The relational data model is usually designed following the well-known normal forms. However, a fully normalized relational model often does not provide sufficient performance, and improper relational model design can easily lead to a slow and unusable relational database for particular operations. Our ORM approach is intended to exploit smart optimization techniques from the relational paradigm that abandon normalization and its positive effects, and trade them off for better performance. Our ORM approach hence combines the classical denormalization transformations, based on reducing or eliminating expensive database operations by the model restructuring, but applies them to a non-redundant conceptual UML model. In this paper, we also present the first step towards this goal: a catalogue of ORM transformation patterns.

Area 10 - Applications and Software Development

Short Papers
Paper Nr: 41
Title:

Towards Product Lining Model-driven Development Code Generators

Authors:

Alexander Roth and Bernhard Rumpe

Abstract: A code generator systematically transforms compact models to detailed code. Today, code generation is regarded as an integral part of model-driven development (MDD). Despite its relevance, the development of code generators is an inherently complex task and common methodologies and architectures are lacking. Additionally, reuse and extension of existing code generators only exist on individual parts. A systematic development and reuse based on a code generator product line is still in its infancy. Thus, the aim of this paper is to identify the mechanism necessary for a code generator product line by (a) analyzing the common product line development approach and (b) mapping those to a code generator specific infrastructure. As a first step towards realizing a code generator product line infrastructure, we present a component-based implementation approach based on ideas of variability-aware module systems and point out further research challenges.

Area 11 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 43
Title:

Polymer - A Model-driven Approach for Simpler, Safer, and Evolutive Multi-objective Optimization Development

Authors:

Assaad Moawad, Thomas Hartmann, Francois Fouquet, Gregory Nain, Jacques Klein and Johann Bourcier

Abstract: Multi-Objective Evolutionary Algorithms (MOEAs) have been successfully used to optimize various domains such as finance, science, engineering, logistics and software engineering. Nevertheless, MOEAs are still very complex to apply and require detailed knowledge about problem encoding and mutation operators to obtain an effective implementation. Software engineering paradigms such as domain-driven design aim to tackle this complexity by allowing domain experts to focus on domain logic over technical details. Similarly, in order to handle MOEA complexity, we propose an approach, using model-driven software engineering (MDE) techniques, to define fitness functions and mutation operators without MOEA encoding knowledge. Integrated into an open source modelling framework, our approach can significantly simplify development and maintenance of multi-objective optimizations. By leveraging modeling methods, our approach allows reusable optimizations and seamlessly connects MOEA and MDE paradigms. We evaluate our approach on a cloud case study and show its suitability in terms of i) complexity to implement an MOO problem, ii) complexity to adapt (maintain) this implementation caused by changes in the domain model and/or optimization goals, and iii) show that the efficiency and effectiveness of our approach remains comparable to ad-hoc implementations.

Paper Nr: 44
Title:

Automated State-based Online Testing Real-time Embedded Software with RTEdge

Authors:

Wafa Hasanain, Yvan Labiche and Serban Gheorghe

Abstract: Verifying a real time embedded application is challenging since one has to consider timing requirements in addition to functional ones. During online state-based testing the generation and execution of test cases happen concurrently: test case generation uses information from a state-based test model in combination with observed execution behaviour. This paper describes a practical online testing algorithm that is implemented in the state-based modeling tool RTEdge. Two case studies show that our online testing algorithm produces a test suite that achieves high model coverage, thus facilitating the automated verification of real-time embedded software.

Area 12 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 47
Title:

A Modular Method for Global System Behaviour Specification

Authors:

Urooj Fatima and Rolv Bræk

Abstract: The challenge addressed in this paper is that how can we specify the global behaviour of distributed reactive systems in a way which eases the comprehension of the system without compromising its specification’s correctness, completeness, modularity and readability. Instead of defining the global behaviour models in a monolithic way, we approach the problem by decomposing the specification into interface functionality and core functionality. The resulting interface-modular method for system specification is presented and discussed in this paper using a TaxiCentral as case study. The novelty of this method lies in the clear separation of interfaces from core functionality in global specification, and the use of activity diagrams in combination with collaborations to express and compose the specifications.

Area 13 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 49
Title:

Disciplined Approach for Transformation CIM to PIM in MDA

Authors:

Yassine Rhazali, Youssef Hadi and Abdelaziz Mouloudi

Abstract: This paper suggests a disciplined approach to mastered transformation of CIM level to PIM level in accordance with the MDA approach. Our suggestion is founded on creating good CIM level through well-selected rules, allowing us to achieve rich models that contain relevant information to facilitate the task of the transformation to the PIM level. We specify, thereafter, an appropriate PIM level through different UML points of view (functional, dynamic and static) using a diagram for each one. Next, we present a set of well-defined rules to shift CIM to PIM so as to ensure an automatic transformation, the maximum possible. Our method follows the MDA approach by considering the business dimension in the CIM level, through the use standards modelling business of OMG (BPMN and Activity Diagram), and by using the UML in PIM advocated by MDA in this level.

Paper Nr: 51
Title:

Towards Traceability Modeling for the Engineering of Heterogeneous Systems

Authors:

Nasser Mustafa and Yvan Labiche

Abstract: Capturing traceability information among artifacts allows for assuring product quality in many ways such as tracking functional and non-functional requirements, performing system validation and impact analysis. Although literature provides many techniques to model traceability, existing solutions are either tailored to specific domains (e.g., Ecore modeling languages), or not complete enough (e.g., lack support to specify traceability link semantics). This paper examines the current traceability models and identifies the drawbacks that prevent from capturing some traceability information of heterogeneous artifacts. In this context, heterogeneous artifacts refer to artifacts that come from widely different modelling notations (e.g., UML, Simulink, natural language text, source code). Additionally, the paper proposes traceability model requirements that are necessary to build a generic traceability model. We argue that the proposed requirements are sufficient to build a traceability model oblivious of the heterogeneity of the models which elements need to be traced. We also argue that our proposed requirements can be adopted to create a generic traceability model that provides flexibility and can accommodate new ways of characterizing and imposing constraints on trace links or systems artifacts. The proposed requirements incorporate the ideas from many existing solutions in literature, in an attempt to be as complete as possible.

Paper Nr: 53
Title:

LCL - A Graphical Meta-Language for Specification of Language Constraints

Authors:

Terje Gjøsæter

Abstract: The Object Constraint Language (OCL) is commonly used for constraints in meta-model-based language specifications. However, it may be advantageous to have a domain-specific constraint meta-language optimised for language specifications. A survey of OCL usage in language specifications has been performed, in order to gain an understanding of common constraint patterns. This is used as a starting point for defining a new meta-language for language constraints, Language Constraint Language (LCL), that has an intuitive graphical syntax.

Paper Nr: 59
Title:

A Combined Graph-based Approach for Systems Design And Verification

Authors:

Najet Zoubeir and Adel Khalfallah

Abstract: Software architecture’s interoperability faces many problems when it comes to integrating different components or formalisms in describing the architecture. Even within the same modeling language such as UML, the diversity of notations and the lack of semantic information make the interoperability between models difficult. In this paper, we propose semantic foundations that unify the notations of classes, interactions and constraints, and hence provide a robust basis for models interoperability. We rely on graphs and graph transformations to describe systems structure and behavior, semantics and constraints in a combined form within an integrated framework, which constitutes a robust basis for automated software architecture analysis.

Paper Nr: 63
Title:

The Effect of Concurrent Programming Idioms on Verification - A Position Paper

Authors:

David Harel, Guy Katz, Assaf Marron and Gera Weiss

Abstract: In recent years formal verification techniques have become an important part of the development cycle of concurrent software. In order to tackle the state explosion problem and verify larger systems, a great deal of work has been put into improving the scalability of verification tools. In this work, we seek to draw attention to an alternative/complementary approach to improving scalability, which sometimes receives less notice: the effect the concurrent programming model itself has on one’s ability to verify programs encoded within it. Recent work suggests that a suitable choice of model, tailored to the problem at hand, may render the produced software more amenable to verification techniques. We recapitulate some recent and new results demonstrating this effect in programming models for discrete, synchronous reactive systems, and outline some directions for future work. We hope that the paper will trigger additional research on this important topic.

Area 14 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 66
Title:

Using Software Categories for the Development of Generative Software

Authors:

Pedram Mir Seyed Nazari and Bernhard Rumpe

Abstract: In model-driven development (MDD) software emerges by systematically transforming abstract models to concrete source code. Ideally, performing those transformations is to a large extent the task of code generators. One approach for developing a new code generator is to write a reference implementation and separate it into handwritten and generatable code. Typically, the generator developer manually performs this separation — a process that is often time-consuming, labor-intensive, difficult to maintain and may produce more code than necessary. Software categories provide a way for separating code into designated parts with defined dependencies, for example, “Business Logic” code that may not directly use “Technical” code. This paper presents an approach that uses the concept of software categories to semi-automatically determine candidates for generated code. The main idea is to iteratively derive the categories for uncategorized code from the dependencies of categorized code. The candidates for generated or handwritten code finally are code parts belonging to specific (previously defined) categories. This approach helps the generator developer in finding candidates for generated code more easily and systematically than searching by hand and is a step towards tool-supported development of generative software.

Area 15 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 68
Title:

On Languages for Conceptual Data Modeling in Multi-disciplinary Space Systems Engineering

Authors:

Christian Hennig, Harald Eisenmann, Alexander Viehl and Oliver Bringmann

Abstract: The engineering of complex systems is more and more supported through computer-based models that rely on a comprehensive specification of their underlying data. This paper reflects on extensive industrial experience with a sophisticated application of conceptual data modeling, addressing requirements as they arise in the context of space systems engineering. For this purpose identified needs for conceptual data modeling in the scope of Model-Based Systems Engineering are formulated. Established and evolving approaches and technologies for building conceptual data models are characterized, analyzed, and discussed regarding their suitability for modeling engineering data. Based on this analysis of the state of the art, recommendations for the future evolution of conceptual data modeling are formulated.

Area 16 - Applications and Software Development

Short Papers
Paper Nr: 69
Title:

Variability Management Supporting the Model-driven Design of User Interfaces

Authors:

Jean-Sébastien Sottet, Alain Vagner and Alfonso García Frey

Abstract: User Interfaces (UI) design is a complex and multi-faceted problem. It depends on devices, users and their environments and involves various stakeholders with different backgrounds. Moreover, user requirements are difficult to evaluate precisely upfront and require iterative design cycles based on trial and error. All this variability is complex and should be managed efficiently to ensure moderate design costs. One solution is to implement in the UI design process Model-Driven Engineering (MDE) and Software Product Lines (SPL). However, current SPL approaches do not consider problems related to specific UI design models, notably the many concerns underlying them. We propose an SPL approach that supports the separation of concerns through multi-step partial configuration of UI features. The approach is implemented in our existing MDE UI generation framework.

Area 17 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 70
Title:

Towards the State of the Art of Extending Enterprise Modeling Languages

Authors:

Richard Braun

Abstract: In the previous decade, more and more de facto standards of enterprise modeling languages (EML) evolved. The establishment of EMLs leads naturally to an increasing number of EML extensions in order to integrate requirements and needs from specific problems or domains in an EML. Thus, EML extensibility is proposed as a relevant topic within both the field of meta modeling and enterprise modeling. We therefore conducted an analysis of existing meta modeling languages and well known EML languages in order to derive the current state of the art in terms of EML extensibility. In addition to that, classification schemes for extension purposes and extension mechanisms are presented. Finally, topics for further research are proclaimed in order to facilitate more research on language extensibility.

Paper Nr: 71
Title:

Behind the Scenes of the BPMN Extension Mechanism - Principles, Problems and Options for Improvement

Authors:

Richard Braun

Abstract: The Business Process Model and Notation (BPMN) is a standard for modeling business processes that is widely used and accepted both in academia and industry due to its well-defined meta model, its large set of concepts and its extensibility. BPMN is one of very few modeling languages that provides an integrated extension mechanism. However, the mechanism is not often implemented in research articles or in professional practice. We suppose, that both syntactical and methodical aspects within the BPMN extension mechanism may cause misunderstandings and uncertainty regarding its implementation. Therefore, we conducted an in-depth analysis of the extension mechanism in order to rationally figure out problematic aspects. These aspects are consolidated and compared to two existing BPMN extension methods. Based on that, a range of further research topics is finally derived.

Paper Nr: 75
Title:

A Mechanism for Data Interchange Between Embedded Software Sub-systems Developed using Heterogenous Modeling Domains

Authors:

Padma Iyenghar, Benjamin Samson, Michael Spieker, Arne Noyer, Juergen Wuebbelmann, Clemens Westerkamp and Elke Pulvermueller

Abstract: In the domain of embedded systems, the complexities involved in embedded software development are being successfully addressed by the emerging field of model-based software development and testing. However, in embedded systems, the underlying embedded software is often expected to collaborate with various hardware, mechanical, electrical modules/technologies. To address this aspect of heterogeneity in embedded systems, practitioners of model-based embedded software engineering are required to use more than one modeling language. This is essential to address the multi-faceted design aspects/requirements of an embedded system. This paper elaborates on the existing data interchange and coupling mechanisms between embedded software sub-systems modeled using UML and Matlab/Simulink. While there are some existing coupling mechanisms for data exchange among heterogenous modeling domains, they are all not applicable to all real-time operating systems and/or limited to a few simulation studies. This paper addresses the aforementioned gaps and proposes a simple, generic methodology for data exchange between events (in UML domain) and signals (in Matlab/Simulink domain). The proposed approach is elaborated using a seesaw (real-word) embedded software system application scenario example. Initial prototype implementation of the proposed approach, experimental results and some future directions are outlined.

Paper Nr: 76
Title:

Model-driven Development for User-centric Well-being Support - From Dynamic Well-being Domain Models to Context-aware Applications

Authors:

Steven Bosems and Marten van Sinderen

Abstract: Applications that can use information obtained through device sensors to alter their behavior are called context-aware. Design and development of such applications is currently done by modeling the application’s context or by using novel requirements engineering methods. If the application is to support the user’s well-being, these methods fall short due to their technical focus. We propose a model-driven approach that deals with the specifics of the well-being domain by using a DSL that captures the user’s personal well-being context. The development method is user-centric, rather than technology focused. Initial user experiments show promising results.

Area 18 - Applications and Software Development

Posters
Paper Nr: 5
Title:

Towards Managing Data Variability in Multi Product Lines

Authors:

Niloofar Khedri and Ramtin Khosravi

Abstract: Multi product lines (MPLs) are systems consisting of collections of interdependent software product lines (SPLs). The dependencies and interactions among the SPLs cause new challenges in variability management. In the case of a large-scale information system MPL, important issues are raised regarding integration of the databases of the individual SPLs comprising the main system. The aim of this paper is to introduce a method to manage the variability in the data model of such systems. To this end, we first address the problem of developing a universal feature model of the MPL, obtained from integrating the feature models of the individual SPLs, incorporating the data interdependencies among the features. Further, we develop the data model of the MPL using a delta-oriented technique, based on the universal feature model. Our method addresses the problem of possible conflicts among the data model elements of different SPLs and proposes techniques to resolve the conflicts based on data model refinements.

Area 19 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 7
Title:

A Novel Approach using Alloy in Domain-specific Language Engineering

Authors:

Rodrigo M. L. M. Moreira and Ana C. R. Paiva

Abstract: Modeling and building software systems for a given specific domain is a complex task. Domain-Specific Languages (DSLs) have been increasingly gaining attention because they are developed to cope with particularities of specific domains. However, DSL development consists in a set of tasks to be performed and some can be error-prone. Identifying the correct set of elements within a DSL and their constraints can be very demanding. Alloy is a popular lightweight intuitive formal language with a simple notation that is easy to read and write. When models of a DSL are specified using Alloy, it becomes possible to generate instances that should represent valid models. So, this paper presents a generic innovative methodology using Alloy in DSL engineering, in order to find and tune language constraints in a systematic way. It also presents an empirical study illustrating the applicability of the proposed methodology.

Area 20 - Methodologies, Processes and Platforms

Posters
Paper Nr: 22
Title:

Tool Integration by Models, Not Only by Metamodels - Applying Modeling to Tool Integration

Authors:

Weiqing Zhang

Abstract: Integration of tools that support different models defined by different metamodels cannot be achieved by integrating or merging the metamodels of the different models, or by making a minimum, common metamodel for these models. However, it can be achieved by making common representatives of the various models and model elements maintained by the tools. This paper has investigated several existing model/metamodel integration approaches, and described an approach where tool integration works by models, not only by metamodels.

Area 21 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 23
Title:

Combined Modelling and Programming Support for Composite States and Extensible State Machines

Authors:

Kjetil Andresen, Birger Møller-Pedersen and Ragnhild Kobro Runde

Abstract: Most modelling languages support full state machine modelling, including especially composite states. Existing approaches to programming with states (state design patterns) either represent composite states by means of inheritance between state classes, or do not support composite states, and instead use inheritance for specialization of extensible state machines. In this paper, we present 1) a state design pattern using delegation to support composite states and inheritance together with virtual classes to support extensible state machines, and 2) a framework, implemented in Java, which also supports history and entry/exit actions. Together, these form the basis for developing support for state machines in a combined modelling and programming language.

Paper Nr: 30
Title:

Automated DSL Construction Based on Software Product Lines

Authors:

Changyun Huang, Ataru Osaka, Yasutaka Kamei and Naoyasu Ubayashi

Abstract: DSL (Domain-Specific Language) is one of the important approaches for software abstraction. In the past decades, DSLs have been provided by expert engineers familiar with domain knowledge and programming language processors. It is not easy for ordinary programmers to construct DSLs for their own purposes. To deal with this problem, we propose a language workbench called Argyle that can automatically generate a DSL by only specifying a set of functions needed to the DSL and an execution platform supported by the DSL. Argyle is based on software product lines and consists of the following two steps: 1) development of the core assets for constructing a family of DSLs and 2) DSL configuration using these core assets. To demonstrate the effectiveness of our approach, we developed a prototype DSL for supporting MSR (Mining Software Repositories), the most active research field in software engineering.

Paper Nr: 31
Title:

Integrating Existing Proprietary System Models into a Model-driven Test Process for an Industrial Automation Scenario

Authors:

Kai Beckmann

Abstract: The introduction of modern model-driven software development methodologies into the industrial practise still proves to be a challenge. Especially small or medium-sized enterprises (SMEs) need an incremental and continuous modernisation process, which incorporates existing projects, is customised and cost-effective. Particularly, suitable solutions for model-based or -driven testing with test automation to increase the efficiency are in demand. This paper presents an approach for integrating existing proprietary system models of an SME partner for describing industrial automation processes into a model-driven test process, utilising a domain-specific language for the test specification. The test objectives focuses on the correct implementation of the communication and synchronisation of distributed state machines. The presented approach is integrated into a test framework, which is based on the Eclipse Modelling Framework (EMF) and the Eclipse Test and Performance Tools Platform Project (TPTP) framework. To separate the possibly changeable system and DSL-specific models from the implementation of the test framework, a stable and more generic test meta model was defined.

Area 22 - Methodologies, Processes and Platforms

Posters
Paper Nr: 42
Title:

Discovering Models of Parallel Workflow Processes from Incomplete Event Logs

Authors:

Julijana Lekic and Dragan Milicev

Abstract: Abstract: Alpha-algorithm is able to discover a large class of workflow (WF) nets based on the behavior recorded in event logs, with the main limiting assumption that the event log is complete. Our research has been aimed at finding ways of business process models discovering based on examples of traces, i.e., logs of workflow actions that do not meet the requirement of completeness. In this aim, we have modified the existing and introduced a new relation between activities recorded in the event log, which has led to a partial correction of the process models discovering techniques, including the α-algorithm. We have also introduced the notions of causally and weakly complete logs, from which our modified algorithm can produce the same result as the original algorithm from complete logs. The effect of these modifications on the speed of the process model discovering is mostly evident for business processes in which many activities can be performed in parallel. Therefore, this paper presents preliminary results obtained from the investigation of opportunities to discover models of parallel processes based on incomplete event logs.

Paper Nr: 45
Title:

Contextual Representations for Enterprise Model Application (C.R.E.M.A.)

Authors:

Nikolaus Wintrich and Malte Meißner

Abstract: Enterprise models help to make enterprise processes and services more transparent while also improving stockholders’ abilities to analyze, optimize and control them. These models include every relevant element as well as enterprise processes, including their relationships with one another. The growing complexity of these models reduces their usability as well as user friendliness. The different stakeholders have different expectations towards the visualization and the relevant information being displayed to them. Therefore contextual representations of enterprise models allow the provision of the relevant information in a user oriented perspective by applying different visualization methods. This helps to manage the complexity and facilitates a sustainable application of enterprise models for various enterprise aspects such as quality management, strategic planning, reporting and operational control.

Area 23 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 48
Title:

Technology Independent Honeynet Description Language

Authors:

Wenjun Fan, David Fernández and Víctor A. Villagrá

Abstract: Several languages have been proposed for the task of describing networks of systems, either to help on managing, simulate or deploy testbeds for testing purposes. However, there is no one specifically designed to describe the honeynets, covering the specific characteristics in terms of applications and tools included in the honeypot systems that make the honeynet. In this paper, the requirements of honeynet description are studied and a survey of existing description languages is presented, concluding that a CIM (Common Information Model) match the basic requirements. Thus, a CIM like technology independent honeynet description language (TIHDL) is proposed. The language is defined being independent of the platform where the honeynet will be deployed later, and it can be translated, either using model-driven techniques or other translation mechanisms, into the description languages of honeynet deployment platforms and tools. This approach gives flexibility to allow the use of a combination of heterogeneous deployment platforms. Besides, a flexible virtual honeynet generation tool (HoneyGen) based on the approach and description language proposed and capable of deploying honeynets over VNX (Virtual Networks over LinuX) and Honeyd platforms is presented for validation purposes.

Paper Nr: 57
Title:

Using a Projectional Editor to Implement Interactive Model Navigation and View Control

Authors:

Tony Clark and Balbir Barn

Abstract: A modelling language typically consists of a collection of sub-languages addressing different aspects of a system. A modelling method consists of rules governing model interaction and view control. Many modelling tools are method agnostic and impose no restrictions on the model development process, others impose fixed methods and views that cannot be changed. Meta-tools offer configuration at the syntax level, but do not provide mechanisms to define the associated interaction processes and views. This paper describes an approach to language definition that includes the specification of how a developer is intended to interact with the language.

Paper Nr: 61
Title:

Metamodelling with Formal Semantics with Application to Access Control Specification

Authors:

Jamal Abd-Ali, Karim El Guemhioui and Luigi Logrippo

Abstract: The visual aspect of metamodelling languages is an efficient lever to deal with the complexity of specifying systems. In many application domains, these systems are generally characterized by the sensitivity and criticality of their contents, hence precision and formalism are essential goals. This paper considers the domain of access control specification languages and proposes a metamodelling paradigm with capabilities for specifying both semantics and structuring elements. We describe how to specify semantics of domain specific systems at the metamodel and model levels. The paradigm defines reusable rules allowing mapping the models, including their semantics, to first order logic programs. It represents a methodical approach to elaborate domain specific languages endowed with visual aspects and means of reasoning on formal specifications. The paradigm is applicable to a wide range of systems. We show in this paper its application in the area of decision systems.

Paper Nr: 64
Title:

Traceability and Interfacing Between Requirements Engineering and UML Domains using the Standardized ReqIF Format

Authors:

Arne Noyer, Padma Iyenghar, Elke Pulvermueller, Florian Pramme and Gert Bikker

Abstract: Model Driven Development (MDD) is deemed as a key to address the increasing complexity of software systems. It is imperative that the developed software fulfills the end-user’s requirements. This implies that a collaboration between the Requirements Management (RM) tools and the modeling tools, enabling complete traceability and interfacing among these tools, is essential. On the other hand, existing tools collaborating between RM and modeling tools support a very limited sub-set of new features (e.g. traceability analysis) and are compatible with only a few tools. As a result, software engineers are often required to educate themselves on another (often complex), intermediate (collaborating) tool, merely to realize a very limited sub-set of supported features. This paper addresses these gaps and introduces an approach for exchanging information between RMtools and Unified Modeling Language (UML) tools by using the standardized Requirements Interchange Format (ReqIF). The proposed approach (a) enables software developers to create links between requirements and UML elements in their modeling tool and (b) facilitates requirements engineers to make traceability/other analyses down to linked model elements inside their RM tool. In contrast to many other approaches, no additional user interface is needed for traceability.

Paper Nr: 65
Title:

Support of Scenario Creation by Generating Event Lists from Conceptual Models

Authors:

Kenta Goto, Shinpei Ogata, Junko Shirogane, Takako Nakatani and Yoshiaki Fukazawa

Abstract: In the requirements definition phase, conceptual models are used to understand the developing software. Although scenarios are often described on the basis of conceptual models, there are cases that necessary requirements are omitted in the scenarios when the scenarios are created manually. Herein we propose an approach to support scenario creation from conceptual models where event lists of scenarios, which include checkpoints to define requirements, are generated from conceptual models automatically. The conceptual models represent the core resources of the software, the owner of the core resources, and use cases as class diagrams. Then software engineers and their clients arrange the event lists and define requirements as scenarios on the basis of the checkpoints. Our approach can support describing scenarios with all the necessary requirements from conceptual models. To confirm the effectiveness of our approach, we compared our approach to the all-manual approach.

Paper Nr: 72
Title:

A Toolchain for Model-based Design and Testing of Access Control Systems

Authors:

Said Daoudagh, Donia El Kateb, Francesca Lonetti, Eda Marchetti and Tejeddine Mouelhi

Abstract: In access control systems, aimed at regulating the accesses to protected data and resources, a critical component is the Policy Decision Point (PDP), which grants or denies the access according to the defined policies. Due to the complexity of the standard languag-e, it is recommended to rely on model-driven approaches which allow to overcome difficulties in the XACML policy definition. We provide in this paper a toolchain that involves a model-driven approach to specify and generate XACML policies and also enables automated testing of the PDP component. We use XACML-based testing strategies for generating appropriate test cases which are able to validate the functional aspects, constraints, permissions and prohibitions of the PDP. An experimental assessment of the toolchain and its use on a realistic case study are also presented.