Skip to main content

Über dieses Buch

The MODELS series of conferences is the premier venue for the exchange of - novative technical ideas and experiences focusing on a very important new te- nical discipline: model-driven software and systems engineering. The expansion ofthisdisciplineisadirectconsequenceoftheincreasingsigni?canceandsuccess of model-based methods in practice. Numerous e?orts resulted in the invention of concepts, languagesand tools for the de?nition, analysis,transformation, and veri?cationofdomain-speci?cmodelinglanguagesandgeneral-purposemodeling language standards, as well as their use for software and systems engineering. MODELS 2010, the 13th edition of the conference series, took place in Oslo, Norway, October 3-8, 2010, along with numerous satellite workshops, symposia and tutorials. The conference was fortunate to have three prominent keynote speakers: Ole Lehrmann Madsen (Aarhus University, Denmark), Edward A. Lee (UC Berkeley, USA) and Pamela Zave (AT&T Laboratories, USA). To provide a broader forum for reporting on scienti?c progress as well as on experience stemming from practical applications of model-based methods, the 2010 conference accepted submissions in two distinct tracks: Foundations and Applications. The primary objective of the ?rst track is to present new research results dedicated to advancing the state-of-the-art of the discipline, whereas the second aims to provide a realistic and veri?able picture of the current state-- the-practice of model-based engineering, so that the broader community could be better informed of the capabilities and successes of this relatively young discipline. This volume contains the ?nal version of the papers accepted for presentation at the conference from both tracks.



Keynote 1

A Unified Approach to Modeling and Programming

SIMULA was a language for modeling and programming and provided a unified approach to modeling and programming in contrast to methodologies based on structured analysis and design. The current development seems to be going in the direction of separation of modeling and programming. The goal of this paper is to go back to the future and get inspiration from SIMULA and propose a unified approach. In addition to reintroducing the contributions of SIMULA and the Scandinavian approach to object-oriented programming, we do this by discussing a number of issues in modeling and programming and argue why we consider a unified approach to be an advantage.
Ole Lehrmann Madsen, Birger Møller-Pedersen

Session 1a: Genericity and Generalization

Generic Meta-modelling with Concepts, Templates and Mixin Layers

Meta-modelling is a key technique in Model Driven Engineering, where it is used for language engineering and domain modelling. However, mainstream approaches like the OMG’s Meta-Object Facility provide little support for abstraction, modularity, reusability and extendibility of (meta-)models, behaviours and transformations.
In order to alleviate this weakness, we bring three elements of generic programming into meta-modelling: concepts, templates and mixin layers. Concepts permit an additional typing for models, enabling the definition of behaviours and transformations independently of meta-models, making specifications reusable. Templates use concepts to express requirements on their generic parameters, and are applicable to models and meta-models. Finally, we define functional layers by means of meta-model mixins which can extend other meta-models.
As a proof of concept we also report on MetaDepth, a multi-level meta-modelling framework that implements these ideas.
Juan de Lara, Esther Guerra

An Observer-Based Notion of Model Inheritance

A model-based engineering discipline presupposes that models are organised by creating relationships between them. While there has been considerable work on understanding what it means to instantiate one model from another, little is known about when a model should be considered to be a specialisation of another one. This paper motivates and discusses ways of defining specialisation relationships between models, languages, and transformations respectively. Several alternatives of defining a specialisation relationship are considered and discussed. The paper’s main contribution is the introduction of the notions of an observer and a context in order to define and validate specialisation relationships. The ideas and discussions presented in this paper are meant to provide a stepping stone towards a systematic basis for organising models.
Thomas Kühne

MDE-Based Approach for Generalizing Design Space Exploration

Design Space Exploration (DSE) is the exploration of design alternatives before the implementation. Existing DSE frameworks are domain-specific where the representation, evaluation method as well as exploration algorithm are tightly coupled with domain-dependent assumptions. Although the tasks involved in DSE are similar, the inflexibility of the existing frameworks restricts their reuse for solving DSE problems from other domains.
This paper presents an MDE-based approach for generalizing DSE techniques. The framework supports a reconfigurable representation of a design space, which is decoupled from exploration algorithm. The framework can be configured to solve DSE problems from different domains and enables the designer to experiment with different approaches to solve the same problem with minimum effort. The main contributions of this framework are: (1) rapid modeling of DSE problems, (2) reuse of previously defined artifacts, (3) multiple solver support and (4) a tool for scalability study.
Tripti Saxena, Gabor Karsai

Session 1b: Model Migration and Incremental Manipulation

A Comparison of Model Migration Tools

Modelling languages and thus their metamodels are subject to change. When a metamodel evolves, existing models may no longer conform to the evolved metamodel. To avoid rebuilding them from scratch, existing models must be migrated to conform to the evolved metamodel. Manually migrating existing models is tedious and error-prone. To alleviate this, several tools have been proposed to build a migration strategy that automates the migration of existing models. Little is known about the advantages and disadvantages of the tools in different situations. In this paper, we thus compare a representative sample of migration tools – AML, COPE, Ecore2Ecore and Epsilon Flock – using common migration examples. The criteria used in the comparison aim to support users in selecting the most appropriate tool for their situation.
Louis M. Rose, Markus Herrmannsdoerfer, James R. Williams, Dimitrios S. Kolovos, Kelly Garcés, Richard F. Paige, Fiona A. C. Polack

Incremental Evaluation of Model Queries over EMF Models

Model-driven development tools built on industry standard platforms, such as the EclipseModeling Framework (EMF), heavily utilize model queries in model transformation, well-formedness constraint validation and domain-specific model execution. As these queries are executed rather frequently in interactive modeling applications, they have a significant impact on runtime performance and end user experience. However, due to their complexity, these queries can be time consuming to implement and optimize on a case-by-case basis. Consequently, there is a need for a model query framework that combines an easy-to-use and concise declarative query formalism with high runtime performance.
In this paper, we propose a declarative EMF model query framework using the graph pattern formalism as the query specification language. These graph patterns describe the arrangement and properties of model elements that correspond to, e.g. a well-formedness constraint, or an application context of a model transformation rule.
For improved runtime performance, we employ incremental pattern matching techniques: matches of patterns are stored and incrementally maintained upon model manipulation. As a result, query operations can be executed instantly, independently of the complexity of the constraint and the size of the model. We demonstrate our approach in an industrial (AUTOSAR) model validation context and compare it against other solutions.
Gábor Bergmann, Ákos Horváth, István Ráth, Dániel Varró, András Balogh, Zoltán Balogh, András Ökrös

Active Operations on Collections

Collections are omnipresent within models: collections of references can represent relations between objects, and collections of values can represent object attributes. Consequently, manipulating models often consists of performing operations on collections. For example, transformations create target collections from given source collections. Similarly, constraint evaluations perform computation on collections. Recent research works focus on making such transformations or constraint evaluations active (i.e. incremental, or live). However, they propose their own solutions to the issue by the introduction of specific languages and/or systems. This paper proposes a mathematical formalism, centered on collections and independent of languages and systems, that describes how the implementation of standard operations on collections can be made active. The formalism also introduces a reversed active assignment dedicated to bidirectional operations. A case study illustrates how to use the formalism and its Active Kermeta implementation for creating an active transformation.
Olivier Beaudoux, Arnaud Blouin, Olivier Barais, Jean-Marc Jézéquel

Session 1c: Modeling Model Transformations

transML: A Family of Languages to Model Model Transformations

Model transformation is one of the pillars of Model-Driven Engineering (MDE). The increasing complexity of systems and modelling languages has dramatically raised the complexity and size of model transformations. Even though many transformation languages and tools have been proposed in the last few years, most of them are directed to the implementation phase of transformation development. However, there is a lack of cohesive support for the other phases of the transformation development, like requirements, analysis, design and testing.
In this paper, we propose a unified family of languages to cover the life-cycle of transformation development. Moreover, following an MDE approach, we provide tools to partially automate the progressive refinement of models between the different phases and the generation of code for specific transformation implementation languages.
Esther Guerra, Juan de Lara, Dimitrios S. Kolovos, Richard F. Paige, Osmar Marchi dos Santos

Henshin: Advanced Concepts and Tools for In-Place EMF Model Transformations

The Eclipse Modeling Framework (EMF) provides modeling and code generation facilities for Java applications based on structured data models. Henshin is a new language and associated tool set for in-place transformations of EMF models. The Henshin transformation language uses pattern-based rules on the lowest level, which can be structured into nested transformation units with well-defined operational semantics. So-called amalgamation units are a special type of transformation units that provide a forall-operator for pattern replacement. For all of these concepts, Henshin offers a visual syntax, sophisticated editing functionalities, execution and analysis tools. The Henshin transformation language has its roots in attributed graph transformations, which offer a formal foundation for validation of EMF model transformations. The transformation concepts are demonstrated using two case studies: EMF model refactoring and meta-model evolution.
Thorsten Arendt, Enrico Biermann, Stefan Jurack, Christian Krause, Gabriele Taentzer

A Technique for Automatic Validation of Model Transformations

We present in this paper a technique for proving properties about model transformations. The properties we are concerned about relate the structure of an input model with the structure of the transformed model. The main highlight of our approach is that we are able to prove the properties for all models, i.e. the transformation designer may be certain about the structural soundness of the results of his/her transformations. In order to achieve this we have designed and experimented with a transformation model checker, which builds what we call a state space for a transformation. That state space is then used as in classical model checking to prove the property or, in case the property does not hold to produce a counterexample. If the property holds this information can be used as a certification for the transformation, otherwise the counterexample can be used as debug information during the transformation design process.
Levi Lúcio, Bruno Barroca, Vasco Amaral

Session 2a: Verifying Consistency and Conformance

Static- and Dynamic Consistency Analysis of UML State Chart Models

UML state chart models describing the behavior of a system can be used as a formal specification thereof. The existence of advanced modeling tools allows for model simulation and enables the execution of manually created tests on the models. In this work the usage of static and dynamic model analysis techniques is proposed to reveal errors in these models. The static analysis focuses on the syntax, communication structure and non-determinism. The dynamic analysis is based on a random test approach and can reveal bugs like deadlocks and inter-model loops. Further the data generated during the dynamic analysis allows for additional correctness checks such as e.g. the number or lengths of paths. The presented approach is implemented in a prototype and revealed several bugs in an industrial case study not found during simulation and manual model testing.
Christian Schwarzl, Bernhard Peischl

Verifying Semantic Conformance of State Machine-to-Java Code Generators

When applying model-driven engineering to safety-critical systems, the correctness of model transformations is crucial. In this paper, we investigate a novel approach to verifying the conformance to source language semantics of model-to-code transformations that uses annotations in the generated code. These annotations are inserted by the transformation and are used to guide a model checker to verify that the generated code satisfies the semantics of the source language – UML state machines in this paper. Verifying the generated output in this way is more efficient than formally verifying the transformation’s definition. The verification is performed using Java Pathfinder (JPF) [1], a model checker for Java source code. The approach has been applied to verify three UML state machine to Java code generators: one developed by us and two commercial generators (Rhapsody and Visual Paradigm). We were able to detect non-conformance in both commercial tools, which failed some semantic properties extracted from the UML specification.
Lukman Ab Rahim, Jon Whittle

A Dynamic-Priority Based Approach to Fixing Inconsistent Feature Models

In feature models’ construction, one basic task is to ensure the consistency of feature models, which often involves detecting and fixing of inconsistencies in feature models. Several approaches have been proposed to detect inconsistencies, but few focus on the problem of fixing inconsistent feature models. In this paper, we propose a dynamic-priority based approach to fixing inconsistent feature models, with the purpose of helping domain analysts find solutions to inconsistencies efficiently. The basic idea of our approach is to first recommend a solution automatically, then gradually reach the desirable solution by dynamically adjusting priorities of constraints. To this end, we adopt the constraint hierarchy theory to express the degree of domain analysts’ confidence on constraints (i.e. the priorities of constraints) and resolve inconsistencies among constraints. Two case studies have been conducted to demonstrate the usability and scalability of our approach.
Bo Wang, Yingfei Xiong, Zhenjiang Hu, Haiyan Zhao, Wei Zhang, Hong Mei

Session 2b: Taming Modeling Complexity

Taming Graphical Modeling

Visual models help to understand complex systems. However, with the user interaction paradigms established today, activities such as creating, maintaining or browsing visual models can be very tedious. Valuable engineering time is wasted with archaic activities such as manual placement and routing of nodes and edges. This paper presents an approach to enhance productivity by focusing on the pragmatics of model-based design.
Our contribution is twofold: First, the concept of meta layout enables the synthesis of different diagrammatic views on graphical models. This modularly employs sophisticated layout algorithms, closing the gap between MDE and graph drawing theory. Second, a view management logic harnesses this auto-layout to present customized views on models.
These concepts have been implemented in the open source Kiel Integrated Environment for Layout Eclipse Rich Client (kieler). Two applications—editing and simulation—illustrate how view management helps to increase developer productivity and tame model complexity.
Hauke Fuhrmann, Reinhard von Hanxleden

Taming EMF and GMF Using Model Transformation

EMF and GMF are powerful frameworks for implementing tool support for modelling languages in Eclipse. However, with power comes complexity; implementing a graphical editor for a modelling language using EMF and GMF requires developers to hand craft and maintain several low-level interconnected models through a loosely-guided, labour-intensive and error-prone process. In this paper we demonstrate how the application of model transformation techniques can help with taming the complexity of GMF and EMF and deliver significant productivity, quality, and maintainability benefits. We also present EuGENia, an open-source tool that implements the proposed approach, illustrate its functionality through an example, and report on the community’s response to the tool.
Dimitrios S. Kolovos, Louis M. Rose, Saad Bin Abid, Richard F. Paige, Fiona A. C. Polack, Goetz Botterweck

A Visual Traceability Modeling Language

Software traceability is effort intensive and must be applied strategically in order to maximize its benefits and justify its costs. Unfortunately, development tools provide only limited support for traceability, and as a result users often construct trace queries using generic query languages which require intensive knowledge of the data-structures in which artifacts are stored. In this paper, we propose a usage-centered traceability process that utilizes UML class diagrams to define traceability strategies for a project and then visually represents trace queries as constraints upon subsets of the model. The Visual Trace Modeling Language (VTML) allows users to model queries while hiding the underlying technical details and data structures. The approach has been demonstrated through a prototype system and and evaluated through a preliminary experiment to evaluate the expressiveness and readability of VTML in comparison to generic SQL queries.
Patrick Mäder, Jane Cleland-Huang

Session 2c: Modeling User-System Interaction

Application Logic Patterns – Reusable Elements of User-System Interaction

Patterns of various kind are commonly used to reduce costs and improve quality in software development. This paper introduces the concept of patterns at the level of detailed descriptions of the user-system dialogue. Application Logic Patterns define generalised sequences of interactions performed by the system and its users in the context of an abstract problem domain. The patterns are organised into a library. They are precisely described by a language which is defined through a strict meta-model. It extends the notation and semantics of the UML activities and use cases. Each of the patterns describing the visible system dynamics is linked to an abstract domain model central to all the patterns. The patterns can be easily instantiated by substituting abstract domain notions with the notions specific to a given domain. This ease of use and reduction in effort is validated in a controlled experiment using an open-source tool.
Albert Ambroziewicz, Michał Śmiałek

A Metamodel-Based Approach for Automatic User Interface Generation

One of the advantages of following a MDA-based approach in the development of interactive applications is the possibility of generating multiple platform-specific user interfaces (UI) from the same platform independent UI model. However, the effort required to create the UI model may be significant. In the case of data-intensive applications, a large part of the UI structure and functionality is closely related with the structure and functionality of the domain entities described in the domain model, and the access rules specified in the use case model. This paper presents an approach to reduce the effort required to create platform independent UI models for data intensive applications, by automatically generating an initial UI model from domain and use case models. For that purpose, UML-aligned metamodels for domain and use case models are defined, together with a MOF-based metamodel for user interface models. The transformation rules that drive the UI model generation are introduced. It is also proposed a MDA-based process for the development of data intensive interactive applications based on the proposed model architecture and transformations.
António Miguel Rosado da Cruz, João Pascoal Faria

Rapid UI Development for Enterprise Applications: Combining Manual and Model-Driven Techniques

UI development for enterprise applications is a time-consuming and error-prone task. In fact, approximately 50% of development resources are devoted to UI implementation tasks [1]. Model-driven UI development aims to reduce this effort. However, the quality of the final layout is a problem of this approach, especially when dealing with large and complex domain models. We share our experience in successfully using model-driven UI development in a large-scale enterprise project. Our approach mitigates the problems of model-driven UI development by combining manual layout with automatic inference of UI elements from a given domain model. Furthermore, we provide means to influence the UI generation at design time and to customize the UI at runtime. Thus, our approach significantly reduces the UI implementation effort while retaining control of the resulting UI.
Arne Schramm, André Preußner, Matthias Heinrich, Lars Vogel

Session 3a: Model-Driven Quality Assurance

Environment Modeling with UML/MARTE to Support Black-Box System Testing for Real-Time Embedded Systems: Methodology and Industrial Case Studies

The behavior of real-time embedded systems (RTES) is driven by their environment. Independent system test teams normally focus on black-box testing as they have typically no easy access to precise design information. Black-box testing in this context is mostly about selecting test scenarios that are more likely to lead to unsafe situations in the environment. Our Model-Based Testing (MBT) methodology explicitly models key properties of the environment, its interactions with the RTES, and potentially unsafe situations triggered by failures of the RTES under test. Though environment modeling is not new, we propose a precise methodology fitting our specific purpose, based on a language that is familiar to software testers, that is the UML and its extensions, as opposed to technologies geared towards simulating natural phenomena. Furthermore, in our context, simulation should only be concerned with what is visible to the RTES under test. Our methodology, focused on black-box MBT, was assessed on two industrial case studies. We show how the models are used to fully automate black-box testing using search-based test case generation techniques and the generation of code simulating the environment.
Muhammad Zohaib Iqbal, Andrea Arcuri, Lionel Briand

Improving Test Models for Large Scale Industrial Systems: An Inquisitive Study

Although documentation of software tests is becoming increasingly important, there is little knowledge on whether modeling languages and tools are effective in industrial projects. Recent reports have pointed out that test modeling techniques might be barely used by software developers due to their inability to cover test concepts relevant in real-life large applications. This paper reports an inquisitive multi-phase study aimed at revealing test-relevant concepts not supported by modeling languages. The study encompassed several questionnaire responses and interviews with developers, and observational analyses run over two years in large-scale software projects. Various test concepts were brought forth and they fall in three categories: (i) test cases and software evolution, (ii) interdependencies between test cases, and (iii) categorization and grouping of test cases. Finally, the relevance of the identified test concepts is discussed in terms of an industrial system for inventory and supply control of petroleum products.
Andrew Diniz da Costa, Viviane Torres da Silva, Alessandro Garcia, Carlos José Pereira de Lucena

Automatically Discovering Properties That Specify the Latent Behavior of UML Models

Formal analysis can be used to verify that a model of the system adheres to its requirements. As such, traditional formal analysis focuses on whether known (desired) system properties are satisfied. In contrast, this paper proposes an automated approach to generating temporal logic properties that specify the latent behavior of existing UML models; these are unknown properties exhibited by the system that may or may not be desirable. A key component of our approach is Marple, a evolutionary-computation tool that leverages natural selection to discover a set of properties that cover different regions of the model state space. The Marple-discovered properties can be used to refine the models to either remove unwanted behavior or to explicitly document a desirable property as required system behavior. We use Marple to discover unwanted latent behavior in two applications: an autonomous robot navigation system and an automotive door locking control system obtained from one of our industrial collaborators.
Heather J. Goldsby, Betty H. C. Cheng

Session 3b: Managing Variability

Towards a Semantics of Activity Diagrams with Semantic Variation Points

UML activity diagrams have become an established notation to model control and data flow on various levels of abstraction, ranging from fine-grained descriptions of algorithms to high-level workflow models in business applications. A formal semantics has to capture the flexibility of the interpretation of activity diagrams in real systems, which makes it inappropriate to define a fixed formal semantics. In this paper, we define a semantics with semantic variation points that allow for a customizable, application-specific interpretation of activity diagrams. We examine concrete variants of the activity diagram semantics which may also entail variants of the syntax reflecting the intended use at hand.
Hans Grönniger, Dirk Reiß, Bernhard Rumpe

An AADL-Based Approach to Variability Modeling of Automotive Control Systems

While the complexity of automotive systems is increasing, nowadays, most of the newly developed functionalities are implemented by software. This implies that software plays an important role in the development of automotive systems. However, several inefficiency problems related to software remain unresolved. One problem is to find an effective way to handle a large-scale variation of automotive systems. Hence, this paper presents an AADL (Architecture Analysis & Design Language)-based approach to the variation-related problem. The proposed approach captures the variation of automotive systems and yields their variability models. The obtained models promote an efficient development that exploits system variation. In this paper, we explain the detailed procedure of AADL-based development with the help of an example of development of cruise control systems.
Shin’ichi Shiraishi

Extending Variability for OCL Interpretation

In recent years, OCL advanced from a language used to constrain UML models to a constraint language that is applied to various modelling languages. This includes Domain Specific Languages (DSLs) and meta-modelling languages like MOF or Ecore. Consequently, it is rather common to provide variability for OCL parsers to work with different modelling languages. A second variability dimension relates to the technical space that models are realised in. Current OCL interpreters do not support such variability as their implementation is typically bound to a specific technical space like Java, Ecore, or a specific model repository. In this paper we propose a generic adaptation architecture for OCL that hides models and model instances behind well-defined interfaces. We present how the implementation of such an architecture for DresdenOCL enables reuse of the same OCL interpreter for various technical spaces and evaluate our approach in three case studies.
Claas Wilke, Michael Thiele, Christian Wende

Session 3c: Multi-Modeling Approaches

Inter-modelling: From Theory to Practice

We define inter-modelling as the activity of building models that describe how modelling languages should be related. This includes many common activities in Model Driven Engineering, like the specification of model-to-model transformations, the definition of model matching and model traceability constraints, the development of inter-model consistency maintainers and exogenous model management operators.
Recently, we proposed a formal approach to specify the allowed and forbidden relations between two modelling languages by means of bidirectional declarative patterns. Such specifications were used to generate graph rewriting rules able to enforce the relations in (forward and backward) model-to-model transformation scenarios. In this paper we extend the usage of patterns for two further inter-modelling scenarios – model matching and model traceability – and report on an EMF-based tool implementing them. The tool allows a high-level analysis of specifications based on the theory developed so far, as well as manipulation of traces by compilation of patterns into the Epsilon Object Language.
Esther Guerra, Juan de Lara, Dimitrios S. Kolovos, Richard F. Paige

Consistent Modeling Using Multiple UML Profiles

The design of complex technical system invariably involves multiple domain-specific languages to cover the many different facets of such systems. However, unless the languages are designed to be used in combination, this typically leads to conflicting specifications that are difficult to reconcile due to the ontological and other differences between the languages used. In this paper, we describe a pragmatic but systematic approach to resolving this problem for the special but common case in which the domain-specific languages are all defined as UML profiles.
Florian Noyrit, Sébastien Gérard, François Terrier, Bran Selic

A Systematic Review on the Definition of UML Profiles

This article reports a systematic review on the definition of UML profiles in the research literature. Several exploratory statistical analyses have been performed in order to characterise both the idiosyncrasy of UML profiles and how they are reported in the literature. This study uncovers the differences between presentation styles for behavioural and structural domains, and shows how UML profiles based on Class, Association, and Property structural metaclasses clearly outnumber any other kind. Also, this review reveals how half of the examined UML profiles merely extend the abstract syntax, without adding neither icons nor constraints. The main contribution of this study is therefore a clear picture of the state-of-the-art in UML profiling, together with a set of open questions regarding its future.
Jesús Pardillo


Weitere Informationen

Premium Partner