Skip to main content

Über dieses Buch

This book constitutes the refereed proceedings of the 17th International Conference on Model Driven Engineering Languages and Systems, MODELS 2014, held in Valencia, Spain, in September/October 2014. The 41 full papers presented in this volume were carefully reviewed and selected from a total of 126 submissions. The scope of the conference series is broad, encompassing modeling languages, methods, tools, and applications considered from theoretical and practical angles and in academic and industrial settings. The papers report on the use of modeling in a wide range of cloud, mobile, and web computing, model transformation behavioral modeling, MDE: past, present, future, formal semantics, specification, and verification, models at runtime, feature and variability modeling, composition and adaptation, practices and experience, modeling for analysis, pragmatics, model extraction, manipulation and persistence, querying, and reasoning.



Cloud, Mobile and Web Computing

Model-Driven Development of Mobile Applications Allowing Role-Driven Variants

Rapidly increasing numbers of applications and users make the development of mobile applications to one of the most promising fields in software engineering. Due to short time-to-market, differing platforms and fast emerging technologies, mobile application development faces typical challenges where model-driven development can help. We present a modeling language and an infrastructure for the model-driven development (MDD) of Android apps supporting the specification of different app variants according to user roles. For example, providing users may continuously configure and modify custom content with one app variant whereas end users are supposed to use provided content in their variant. Our approach allows a flexible app development on different abstraction levels: compact modeling of standard app elements, detailed modeling of individual elements, and separate provider models for specific custom needs. We demonstrate our MDD-approach at two apps: a phone book manager and a conference guide being configured by conference organizers for participants.

Steffen Vaupel, Gabriele Taentzer, Jan Peer Harries, Raphael Stroh, René Gerlach, Michael Guckert

A Model-Based System to Automate Cloud Resource Allocation and Optimization

Cloud computing offers a flexible approach to elastically allocate computing resources for web applications without significant upfront hardware acquisition costs. Although a diverse collection of cloud resources is available, choosing the most optimized and cost-effective set of cloud resources to meet the QoS requirements is not a straightforward task. Manual load testing, monitoring of resource utilization, followed by bottleneck analysis is time consuming and complex due to limitations of the abstractions of load testing tools, challenges characterizing resource utilization, significant manual test orchestration effort, and complexity of selecting resource configurations to test. This paper introduces a model-based approach to simplify, optimize, and automate cloud resource allocation decisions to meet QoS goals for web applications. Given a high-level application description and QoS requirements, the model-based approach automatically tests the application under a variety of load and resources to derive the most cost-effective resource configuration to meet the QoS goals.

Yu Sun, Jules White, Sean Eade

An Evaluation of the Effectiveness of the Atomic Section Model

Society increasingly depends on web applications for business and pleasure. As the use of web applications continues to increase, the number of failures, some minor and some major, continues to grow. A significant problem is that we still have relatively weak abilities to test web applications. Traditional testing techniques do not adequately model or test these novel technologies. The atomic section model (ASM), models web applications to support design, analysis, and testing. This paper presents an empirical study to evaluate the effectiveness of the ASM. The model was implemented into a tool, WASP, which extracts the ASM from the implementation and supports various test criteria. We studied ten web applications, totaling 156 components and 11,829 lines of code. Using WASP, we generated 207 tests, which revealed 31 faults.Seventeen of those faults exposed internal information about the application and server.

Sunitha Thummala, Jeff Offutt

Model Transformation 1

Parsing in a Broad Sense

Having multiple representations of the same instance is common in software language engineering: models can be visualised as graphs, edited as text, serialised as XML. When mappings between such representations are considered, terms “parsing” and “unparsing” are often used with incompatible meanings and varying sets of underlying assumptions. We investigate 12 classes of artefacts found in software language processing, present a case study demonstrating their implementations and state-of-the-art mappings among them, and systematically explore the technical research space of bidirectional mappings to build on top of the existing body of work and discover as of yet unused relationships.

Vadim Zaytsev, Anya Helene Bagge

Streaming Model Transformations By Complex Event Processing

Streaming model transformations represent a novel class of transformations dealing with models whose elements are continuously produced or modified by a background process [1]. Executing streaming transformations requires efficient techniques to recognize the activated transformation rules on a potentially infinite input stream. Detecting a series of events triggered by compound structural changes is especially challenging for a high volume of rapid modifications, a characteristic of an emerging class of applications built on runtime models.

In this paper, we propose a novel approach for streaming model transformations by combining incremental model query techniques with complex event processing (CEP) and reactive (event-driven) transformations. The event stream is automatically populated from elementary model changes by the incremental query engine, and the CEP engine is used to identify complex event combinations, which are used to trigger the execution of transformation rules. We demonstrate our approach in the context of automated gesture recognition over live models populated by


sensor data.

István Dávid, István Ráth, Dániel Varró

On the Use of Signatures for Source Incremental Model-to-text Transformation

Model-to-text (M2T) transformation is an important model management operation, used to implement code and documentation generation, model serialisation (enabling model interchange), and model visualisation and exploration. Despite the importance of M2T transformation, contemporary M2T transformation languages cannot be used to easily produce transformations that scale well as the size of the input model increases, which limits their applicability in practice. In this paper, we propose an extension to template-based M2T languages that adds support for signatures, lightweight and concise proxies for templates, which are used to reduce the time taken to re-execute a M2T transformation in response to changes to the input model. We report our initial results in applying signatures to two existing M2T transformations, which indicate a reduction of 33-47% in transformation execution time.

Babajide Ogunyomi, Louis M. Rose, Dimitrios S. Kolovos

Behavioral Modeling

Modeling Systemic Behavior by State-Based Holonic Modular Units

The paper explores a vision in modeling the behavior of complex systems by modular units hosting state machines arranged in part-whole hierarchies and communicating through event flows. Each modular unit plays at the same time the double role of part and whole, i.e. it is inspired by the philosophical idea of holon, providing both an interface and an implementation by which other component state machines may be controlled in order to achieve a global behavior. It is moreover observed that it is possible to assign a formal characterization to such state modules, due to their part-whole arrangement, since higher-level behaviors can derive formally their meaning from lower-level component behaviors. Such a way of arranging behavioral modules allows to establish directly correct-by-construction safety and liveness properties of state-based systems thus challenging the current approach by which state machines interact at the same level and have to be model-checked for ensuring correctness.

Luca Pazzi

Semantic Model Differencing Utilizing Behavioral Semantics Specifications

Identifying differences among models is a crucial prerequisite for several development and change management tasks in model-driven engineering. The majority of existing model differencing approaches focus on revealing syntactic differences which can only approximate semantic differences among models. Significant advances in semantic model differencing have been recently made by Maoz

et al

[16] who propose semantic diff operators for UML class and activity diagrams. In this paper, we present a generic semantic differencing approach which can be instantiated to realize semantic diff operators for specific modeling languages. Our approach utilizes the behavioral semantics specification of the considered modeling language, which enables to execute models and capture execution traces representing the models’ semantic interpretation. Based on this semantic interpretation, semantic differences can be revealed.

Philip Langer, Tanja Mayerhofer, Gerti Kappel

Formalizing Execution Semantics of UML Profiles with fUML Models

UML Profiles are not only sets of annotations. They have semantics. Executing a model on which a profile is applied requires semantics of this latter to be considered. The issue is that in practice semantics of profiles are mainly specified in prose. In this form it cannot be processed by tools enabling model execution. Although latest developments advocate for a standard way to formalize semantics of profiles, no such approach could be found in the literature. This paper addresses this issue with a systematic approach based on fUML to formalize the execution semantics of UML profiles. This approach is validated by formalizing the execution semantics of a subset of the MARTE profile. The proposal is compatible with any tool implementing UML and clearly identifies the mapping between stereotypes and semantic definitions.

Jérémie Tatibouët, Arnaud Cuccuru, Sébastien Gérard, François Terrier

MDE: Past, Present and Future

Who Knows/Uses What of the UML: A Personal Opinion Survey

UML is a comprehensive notation, offering a very large set of diagrams and constructs covering any possible modelling need. As consequence, on one hand, it is difficult and time consuming to master it, and on the other hand, people tend, naturally, to consider only a part of it. In practice, many UML diagrams/constructs seem scarcely used or even their existence is not known. By means of a study covering any possible source of information (e.g. UML books and tools), we started to assess which part of the UML is considered and used in practice. Here, we present some results about knowledge and usage of the UML diagrams by means of a personal opinion survey with 275 participants from both industry and academy, analysing also the influence of different factors: working environment (academia vs. industry), working role, seniority, education, and gender.

Gianna Reggio, Maurizio Leotta, Filippo Ricca

Assessing the State-of-Practice of Model-Based Engineering in the Embedded Systems Domain

Model-Based Engineering (MBE) aims at increasing the effectiveness of engineering by using models as key artifacts in the development process. While empirical studies on the use and the effects of MBE in industry exist, there is only little work targeting the embedded systems domain. We contribute to the body of knowledge with a study on the use and the assessment of MBE in that particular domain. We collected quantitative data from 112 subjects, mostly professionals working with MBE, with the goal to assess the current State of Practice and the challenges the embedded systems domain is facing. Our main findings are that MBE is used by a majority of all participants in the embedded systems domain, mainly for simulation, code generation, and documentation. Reported positive effects of MBE are higher quality and improved reusability. Main shortcomings are interoperability difficulties between MBE tools, high training effort for developers and usability issues.

Grischa Liebel, Nadja Marko, Matthias Tichy, Andrea Leitner, Jörgen Hansson

The Relevance of Model-Driven Engineering Thirty Years from Now

Although model-driven engineering (MDE) is now an established approach for developing complex software systems, it has not been universally adopted by the software industry. In order to better understand the reasons for this, as well as to identify future opportunities for MDE, we carried out a week-long design thinking experiment with 15 MDE experts. Participants were facilitated to identify the biggest problems with current MDE technologies, to identify grand challenges for society in the near future, and to identify ways that MDE could help to address these challenges. The outcome is a reflection of the current strengths of MDE, an outlook of the most pressing challenges for society at large over the next three decades, and an analysis of key future MDE research opportunities.

Gunter Mussbacher, Daniel Amyot, Ruth Breu, Jean-Michel Bruel, Betty H. C. Cheng, Philippe Collet, Benoit Combemale, Robert B. France, Rogardt Heldal, James Hill, Jörg Kienzle, Matthias Schöttle, Friedrich Steimann, Dave Stikkolorum, Jon Whittle

Formal Semantics, Specification and Verification

Model-Driven Verifying Compilation of Synchronous Distributed Applications

We present an approach, based on model-driven verifying compilation, to construct distributed applications that satisfy user-specified safety specifications, assuming a ”synchronous network” model of computation. Given a distributed application



and a safety specification


in a domain specific language


(that we have developed), we first use a combination of sequentialization and software model checking to verify that





. If verification succeeds, we generate an implementation of



that uses a novel barrier-based synchronizer protocol (that we have also developed) to implement the synchronous network semantics. We present the syntax and semantics of


. We also present, and prove correctness of, two sequentialization algorithms, and the synchronizer protocol. Finally, we evaluate the two sequentializations on a collection of distributed applications with safety-critical requirements.

Sagar Chaki, James Edmondson

Environment-Centric Contracts for Design of Cyber-Physical Systems

A contract splits the responsibilities between a component and its environment into a guarantee that expresses an intended property under the responsibility of the component, given that the environment fulfills the assumptions. Although current contract theories are limited to express contracts over interfaces of components, specifications that are not limited to interfaces are used in practice and are needed in order to properly express safety requirements. A framework is therefore presented, generalizing current contract theory to

environment-centric contracts

- contracts that are not limited to the interface of components. The framework includes revised definitions of properties of contracts, as well as theorems that specify exact conditions for when the properties hold. Furthermore, constraints are introduced, limiting the ports over which an environment-centric contract is expressed where the constraints constitute necessary conditions for the guarantee of the contract to hold in an architecture.

Jonas Westman, Mattias Nyberg

Removing Redundancies and Deducing Equivalences in UML Class Diagrams

The emerging Model-driven Engineering approach puts models at the heart of the software development process. The Class Diagram language is central within the UML. Automated support for class diagrams involves identification and repair of





This paper presents methods and rules for improving class diagram quality. The paper introduces formal semantics for class diagrams, which distinguishes between




constraints, and defines redundancy of existential constraints. It provides and analyzes algorithms for removing redundancy of multiplicity and generalization-set constraints in class diagrams with class hierarchy, qualifier, association class, aggregation/composition, and inter-association constraints, and presents inference rules for deducing element equivalence. All methods are under implementation in the



Azzam Maraee, Mira Balaban

Models at Runtime

A Native Versioning Concept to Support Historized Models at Runtime

Models@run.time provides semantically rich reflection layers enabling intelligent systems to reason about themselves and their surrounding context. Most reasoning processes require not only to explore the current state, but also the past history to take sustainable decisions


to avoid oscillating between states. Models@run.time and model-driven engineering in general lack native mechanisms to efficiently support the notion of history, and current approaches usually generate redundant data when versioning models, which reasoners need to navigate. Because of this limitation, models fail in providing suitable and sustainable abstractions to deal with domains relying on history-aware reasoning. This paper tackles this issue by considering history as a native concept for modeling foundations. Integrated, in conjunction with lazy load/storage techniques, into the Kevoree Modeling Framework, we demonstrate onto a smart grid case study, that this mechanisms enable a sustainable reasoning about massive historized models.

Thomas Hartmann, Francois Fouquet, Gregory Nain, Brice Morin, Jacques Klein, Olivier Barais, Yves Le Traon

Modelling Adaptation Policies as Domain-Specific Constraints

In order to develop appropriate adaptation policies for self-adaptive systems, developers usually have to accomplish two main tasks: (i) identify the application-level constraints that regulate the desired system states for the various contexts, and (ii) figure out how to transform the system to satisfy these constraints. The second task is challenging because typically there is complex interaction among constraints, and a significant gap between application domain expertice and state transition expertice. In this paper, we present a model-driven approach that relieves developers from this second task, allowing them to directly write domain-specific constraints as adaptation policies. We provide a language to model both the domain concepts and the application-level constraints. Our runtime engine transforms the model into a Satisfiability Modulo Theory problem, optimises it by pre-processing on the current system state at runtime, and computes required modifications according to the specified constraints using constraints solving. We evaluate the approach addressing a virtual machine placement problem in cloud computing.

Hui Song, Xiaodong Zhang, Nicolas Ferry, Franck Chauvel, Arnor Solberg, Gang Huang

Scalable Armies of Model Clones through Data Sharing

Cloning a model is usually done by duplicating all its runtime objects into a new model. This approach leads to memory consumption problems for operations that create and manipulate large quantities of clones (e.g., design space exploration). We propose an original approach that exploits the fact that operations rarely modify a whole model. Given a set of immutable properties, our cloning approach determines the objects and fields that can be shared between the runtime representations of a model and its clones. Our generic cloning algorithm is parameterized with three strategies that establish a trade-off between memory savings and the ease of clone manipulation. We implemented the strategies within the Eclipse Modeling Framework (EMF) and evaluated memory footprints and computation overheads with 100 randomly generated metamodels and models. Results show a positive correlation between the proportion of shareable properties and memory savings, while the worst median overhead is 9,5% when manipulating the clones.

Erwan Bousse, Benoit Combemale, Benoit Baudry

Feature and Variability Modeling

Three Cases of Feature-Based Variability Modeling in Industry

Large software product lines need to manage complex variability. A common approach is variability modeling—creating and maintaining models that abstract over the variabilities inherent in such systems. While many variability modeling techniques and notations have been proposed, little is known about industrial practices and how industry values or criticizes this class of modeling. We attempt to address this gap with an exploratory case study of three companies that apply variability modeling. Among others, our study shows that variability models are valued for their capability to organize knowledge and to achieve an overview understanding of codebases. We observe centralized model governance, pragmatic versioning, and surprisingly little constraint modeling, indicating that the effort of declaring and maintaining constraints does not always pay off.

Thorsten Berger, Divya Nair, Ralf Rublack, Joanne M. Atlee, Krzysztof Czarnecki, Andrzej Wąsowski

Supporting Multiplicity and Hierarchy in Model-Based Configuration: Experiences and Lessons Learned

When developing large-scale industrial software systems engineers need to instantiate, configure, and deploy diverse reusable components. The number of component instances required depends on customer requirements only known during configuration and is typically unknown when modeling the systems’ variability. Also, the hierarchy of dynamically created component instances leads to complex dependencies between configuration decisions. Dealing with component multiplicity and hierarchy thus requires an approach capable of expressing the dependencies among dynamically instantiated components and configuration decisions. Furthermore, users need tool support for navigating the complex decision space during configuration. In this experience paper we report on applying a decision-oriented modeling approach for defining component variability, multiplicity, and hierarchy. We further present a configuration tool that guides end users through the complex decision space. We report applications of the approach to industrial software systems and describe patterns and lessons learned.

Rick Rabiser, Michael Vierhauser, Paul Grünbacher, Deepak Dhungana, Herwig Schreiner, Martin Lehofer

Propagating Decisions to Detect and Explain Conflicts in a Multi-step Configuration Process

In configuration processes with multiple stakeholders, conflicts are very likely because each decision maker has a different concerns and expectations about the product. They may not be aware of features selected by others or the restrictions that these selections impose. To help solve the conflicts, this paper introduces a new approach to provide


about their causes. Our approach is based on representing features from different concerns using different Feature Models (FMs), and relating them through Feature-Solution Graphs. An FSG contains dependency relationships between two FMs: one feature from the left side forces or prohibits the selection of features in the right side feature model. The strategy to detect and explain conflicts is based on propagation of constraints over the FSGs. We claim that our approach is more expressive and efficient than when using a single FM that contains all concerns and SAT solvers to detect conflicts.

Jaime Chavarriaga, Carlos Noguera, Rubby Casallas, Viviane Jonckers

Composition and Adaptation

An MDA Approach for the Generation of Communication Adapters Integrating SW and FW Components from Simulink

We present the tools, metamodels and code generation techniques in use at Elettronica SpA for the development of communication adapters for software and firmware systems from heterogeneous models. The process start from a SysML system model, developed according to the platform-based design (PBD) paradigm, in which a functional model of the system is paired to a model of the execution platform. Subsystems are refined as Simulink models or hand coded in C++. In turn, Simulink models are implemented as software code or firmware on FPGA, and an automatic generation of the implementation is obtained. Based on the SysML system architecture specification, our framework drives the generation of Simulink models with consistent interfaces, allows the automatic generation of the communication code among all subsystems (including the HW-FW interface code).

Marco Di Natale, Francesco Chirico, Andrea Sindico, Alberto Sangiovanni-Vincentelli

A UML Model-Driven Approach to Efficiently Allocate Complex Communication Schemes

To increase the performance of embedded devices, the current trend is to shift from serial to parallel and distributed computing with simultaneous instructions execution. The performance increase of parallel computing wouldn’t be possible without efficient transfers of data and control information via complex communication architectures. In UML/SysML/MARTE, different solutions exist to describe and map computations onto parallel and distributed systems. However, these languages lack expressiveness to clearly separate computation models from communication ones, thus strongly impacting models’ portability, especially when performing Design Space Exploration. As a solution to this issue, we present Communication Patterns, a novel UML modeling artifact and model-driven approach to assist system engineers in efficiently modeling and mapping communications for parallel and distributed system architectures. We illustrate the effectiveness of our approach with the design of a parallel signal processing algorithm mapped to a multi-processor platform with a hierarchical bus-based interconnect.

Andrea Enrici, Ludovic Apvrille, Renaud Pacalet

Model-Integrating Software Components

In order to handle complexity of software systems, component-based as well as model-driven approaches have become popular in the past. In a model-driven development process the problem arises that over time model and code may be not aligned. Thus, in order to avoid this steadily increasing distance between models and code, we propose the integration of (executable) models and code at the component level. Redundancy – the source of inconsistencies – is reduced by interpreting models directly. Moreover, variability and adaptivity can be achieved by querying and transforming the embedded models. As the basis for such Model-Integrating Components (MoCos), we introduce a component realization concept that is compatible with existing component technologies. We provide a reference implementation using Java, OSGi and TGraphs and apply it successfully in a feasibility study on Android



Mahdi Derakhshanmanesh, Jürgen Ebert, Thomas Iguchi, Gregor Engels

Practices and Experience

Experiences in Applying Model Driven Engineering to the Telescope and Instrument Control System Domain

The development of control systems for large telescopes is frequently challenged by the combination of research and industrial development processes, the bridging of astronomical and engineering domains, the long development and maintenance time-line, and the need to support multiple hardware and software platforms. This paper illustrates the application of a model driven engineering approach to mitigate some of these recurring issues. It describes the lessons learned from introducing a modeling language and creating model transformations for analysis, documentation, simulation, validation, and code generation.

Luigi Andolfato, Robert Karban, Marcus Schilling, Heiko Sommer, Michele Zamparelli, Gianluca Chiozzi

Model Driven Grant Proposal Engineering

We demonstrate the application of Model Driven Engineering techniques to support the development of research grant proposals. In particular, we report on using model-to-text transformation and model validation to enhance productivity and consistency in research proposal writing, and present unanticipated opportunities that were revealed after establishing an MDE infrastructure. We discuss the types of models and the technologies used, reflect on our experiences, and assess the productivity benefits of our MDE solution through automated analysis of data extracted from the version control repository of a successful grant proposal; our evaluation indicates that the use of MDE techniques improved productivity by at least 58%.

Dimitrios S. Kolovos, Nicholas Matragkas, James R. Williams, Richard F. Paige

Agile Model-Driven Engineering in Mechatronic Systems - An Industrial Case Study

Model-driven engineering focuses on structuring systems as well as permitting domain experts to be directly involved in the software development. Agile methods aim for fast feedback and providing crucial knowledge early in the project. In our study, we have seen a successful combination of MDE and agile methods to support the development of complex, software-driven mechatronic systems. We have investigated how combining MDE and agile methods can reduce the number of issues caused by erroneous assumptions in the software of these mechatronic systems. Our results show that plant models to simulate mechanical systems are needed to enable agile MDE during the mechatronic development. They enable developers to run, verify, and validate models before the mechanical systems are delivered from suppliers. While two case studies conducted at Volvo Car Group confirm that combining MDE and agile works, there are still challenges e.g. how to optimize the development of plant models.

Ulf Eliasson, Rogardt Heldal, Jonn Lantz, Christian Berger

Modeling for Analysis

Using UML for Modeling Procedural Legal Rules: Approach and a Study of Luxembourg’s Tax Law

Many laws, e.g., those concerning taxes and social benefits, need to be operationalized and implemented into public administration procedures and eGovernment applications. Where such operationalization is warranted, the legal frameworks that interpret the underlying laws are typically


, providing

procedural rules

for ensuring legal compliance. We propose a UML-based approach for modeling procedural legal rules. With help from legal experts, we investigate actual legal texts, identifying both the information needs and sources of complexity in the formalization of procedural legal rules. Building on this study, we develop a UML profile that enables more precise modeling of such legal rules. To be able to use logic-based tools for compliance analysis, we automatically transform models of procedural legal rules into the Object Constraint Language (OCL). We report on an application of our approach to Luxembourg’s Income Tax Law providing initial evidence for the feasibility and usefulness of our approach.

Ghanem Soltana, Elizabeta Fourneret, Morayo Adedjouma, Mehrdad Sabetzadeh, Lionel Briand

Resolution of Interfering Product Fragments in Software Product Line Engineering

The Common Variability Language (CVL) allows deriving new products in a software product line by substituting fragments (placement) in the base model. Relations between elements of different placement fragments are an issue. Substitutions involving interfering placements may give unexpected and unintended results. However, there is a pragmatic need to define and execute fragments with interference. The need emerges when several diagrams are views of a single model, such as a placement in one diagram and a placement in another diagram reference the same model elements. We handle the issue by 1) classifying interfering fragments, 2) finding criteria to detect them, and 3) suggesting solutions via transformations. We implement our findings in the tooling available for downloading.

Anatoly Vasilevskiy, Øystein Haugen

Ontology-Based Modeling of Context-Aware Systems

Context-aware systems aim to improve the interaction between a computer and a human being by using contextual information about the system itself, the user, and their environment. The number of relevant contextual information is expected to grow rapidly within the next years which tends to result in a complex, error-prone and hence, expensive task of programming context-aware systems. Model-based development can overcome these issues. Current approaches do not allow to model calculation of reliabilities and do not offer options to handle multiple sources of contextual information.

In this paper, we present an approach of modeling contextual information of a context-aware system using the example of a context-aware in-car infotainment system. In particular, we show how developers of context-aware in-car infotainment systems can model reliability calculations of contextual information and handling of multiple sources of contextual information by using a hybrid, ontology-based modeling technique.

Daniel Lüddecke, Nina Bergmann, Ina Schaefer


Comprehending Feature Models Expressed in CVL

Feature modeling is a common way to present and manage variability of software and systems. As a prerequisite for effective variability management is comprehensible representation, the main aim of this paper is to investigate difficulties in understanding feature models. In particular, we focus on the comprehensibility of feature models as expressed in Common Variability Language (CVL), which was recommended for adoption as a standard by the Architectural Board of the Object Management Group. Using an experimental approach with participants familiar and unfamiliar with feature modeling, we analyzed comprehensibility in terms of comprehension score, time spent to complete tasks, and perceived difficulty of different feature modeling constructs. The results showed that familiarity with feature modeling did not influence the comprehension of mandatory, optional, and alternative features, although unfamiliar modelers perceived these elements more difficult than familiar modelers. OR relations were perceived as difficult regardless of the familiarity level, while constraints were significantly better understood by familiar modelers. The time spent to complete tasks was higher for familiar modelers.

Iris Reinhartz-Berger, Kathrin Figl, Øystein Haugen

On the Impact of Layout Quality to Understanding UML Diagrams: Size Matters

Practical experience suggests that usage and understanding of UML diagrams is greatly affected by the quality of their layout. While existing research failed to provide conclusive evidence in support of this hypothesis, our own previous work provided substantial evidence to this effect. When studying different factors like diagram type and expertise level, it became apparent that diagram size plays an important role, too. Since we lack an adequate understanding of this notion, in this paper, we define diagram size metrics and study their impact to modeler performance. We find that there is a strong negative correlation between diagram size and modeler performance. Our results are highly significant. We utilize these results to derive a recommendation on diagram sizes that are optimal for model understanding.

Harald Störrle

Enabling the Development of Cognitive Effective Visual DSLs

The development of graphical editors for visual DSLs is far from being a trivial task. There are consequently several tools that provide technical support for this task. However, this paper shows that the analysis of the main characteristics of such tools leaves some space for improvement as regard the cognitive effectiveness of the visual notations produced with them. To deal with this issue, this work introduces CEViNEdit, a GMF-based framework for the development of visual DSLs which takes into account Moody’s principles for the development and evaluation of graphical notations. To that end, CEViNEdit eases the selection of values for the visual variables of which the notation is composed, computes a set of metrics to assess the appropriateness of these values and then automates the generation of the graphical editor.

David Granada, Juan M. Vara, Veronica A. Bollati, Esperanza Marcos

Model Extraction, Manipulation and Persistence

JUMP—From Java Annotations to UML Profiles

The capability of UML profiles to serve as annotation mechanism has been recognized in both industry and research. Today’s modeling tools offer profiles specific to platforms, such as Java, as they facilitate model-based engineering approaches. However, the set of available profiles is considerably smaller compared to the number of existing Java libraries using annotations. This is because an effective mapping between Java and UML to generate profiles from annotation-based libraries is missing. In this paper, we present


to overcome this limitation, thereby continuing existing mapping efforts by emphasizing on annotations and profiles. We demonstrate the practical value of


by contributing profiles that facilitate reverse-engineering and forward-engineering scenarios for the Java platform. The evaluation of


shows that profiles can be automatically generated from Java libraries exhibiting equal or even improved quality compared to profiles currently used in practice.

Alexander Bergmayr, Michael Grossniklaus, Manuel Wimmer, Gerti Kappel

SIGMA: Scala Internal Domain-Specific Languages for Model Manipulations

Model manipulation environments automate model operations such as model consistency checking and model transformation. A number of external model manipulation

Domain-Specific Languages

(DSL) have been proposed, in particular for the

Eclipse Modeling Framework

(EMF). While their higher levels of abstraction result in gains in expressiveness over general-purpose languages, their limitations in versatility, performance, and tool support together with the need to learn new languages may significantly contribute to accidental complexities.

In this paper, we present


, a family of internal DSLs embedded in Scala for EMF model consistency checking, model-to-model and model-to-text transformations. It combines the benefits of external model manipulation DSLs with general-purpose programming taking full advantage of Scala versatility, performance and tool support. The DSLs are compared to the state-of-the-art Epsilon languages in non-trivial model manipulation tasks that resulted in 20% to 70% reduction in code size and significantly better performance.

Filip Křikava, Philippe Collet, Robert B. France

A Framework to Benchmark NoSQL Data Stores for Large-Scale Model Persistence

We present a framework and methodology to benchmark NoSQL stores for large scale model persistence. NoSQL technologies potentially improve performance of some applications and provide schema-less data-structures, so are particularly suited to persisting large and heterogeneous models. Recent studies consider only a narrow set of NoSQL stores for large scale modelling. Benchmarking many technologies requires substantial effort due to the disparate interface each store provides. Our experiments compare a broad range of NoSQL stores in terms of processor time and disc space used. The framework and methodology is evaluated through a case study that involves persisting large reverse-engineered models of open source projects. The results give tool engineers and practitioners a basis for selecting a store to persist large models.

Seyyed M. Shah, Ran Wei, Dimitrios S. Kolovos, Louis M. Rose, Richard F. Paige, Konstantinos Barmpis

Model Transformation 2

Automated Chaining of Model Transformations with Incompatible Metamodels

In Model-Driven Engineering (MDE) models are first-class entities that are manipulated by means of model transformations. The development of complex and large transformations can benefit from the reuse of smaller ones that can be composed according to user requirements. Composing transformations is a complex problem: typically smaller transformations are discovered and selected by developers from different and heterogeneous sources. Then the identified transformations are chained by means of manual and error-prone composition processes.

In this paper we propose an approach to automatically discover and compose transformations: developers provide the system with the source models and specify the target metamodel. By relying on a repository of model transformations, all the possible transformation chains are calculated. Importantly, in case of incompatible intermediate target and source metamodels, proper adapters are automatically generated in order to chain also transformations that otherwise would be discarded by limiting the reuse possibilities of available transformations.

Francesco Basciani, Davide Di Ruscio, Ludovico Iovino, Alfonso Pierantonio

Classification of Model Transformation Tools: Pattern Matching Techniques

While comparing different model transformation languages (MTLs), it is common to refer to their syntactic and semantic features and overlook their supporting tools’ performance. Performance is one of the aspects that can hamper the application of MDD to industrial scenarios. An highly declarative MTL might simply not scale well when using large models due to its supporting implementation. In this paper, we focus on the several pattern matching techniques (including optimization techniques) employed in the most popular transformation tools, and discuss their effectiveness w.r.t. the expressive power of the languages used. Because pattern matching is the most costly operation in a transformation execution, we present a classification of the existing model transformation tools according to the pattern matching optimization techniques they implement. Our classification complements existing ones that are more focused at syntactic and semantic features of the languages supported by those tools.

Cláudio Gomes, Bruno Barroca, Vasco Amaral

Learning Implicit and Explicit Control in Model Transformations by Example

We propose an evolutionary approach that, in addition to learn model transformation rules from examples, allows to capture implicit and explicit control over the transformation rules. The derivation of both transformation and control knowledge is performed through a heuristic search, i.e., a genetic programming algorithm, guided by the conformance with examples of past transformations supplied as pairs of source and target models. Our approach is evaluated on four model transformation problems that require non-trivial control. The obtained results are convincing for three of the four studied problems.

Islem Baki, Houari Sahraoui, Quentin Cobbaert, Philippe Masson, Martin Faunes


IncQuery-D: A Distributed Incremental Model Query Framework in the Cloud

Queries are the foundations of data intensive applications. In model-driven software engineering (MDE), model queries are core technologies of tools and transformations. As software models are rapidly increasing in size and complexity, traditional tools exhibit scalability issues that decrease productivity and increase costs [17]. While scalability is a hot topic in the database community and recent NoSQL efforts have partially addressed many shortcomings, this happened at the cost of sacrificing the ad-hoc query capabilities of SQL. Unfortunately, this is a critical problem for MDE applications due to their inherent workload complexity. In this paper, we aim to address both the scalability and ad-hoc querying challenges by adapting incremental graph search techniques – known from the


framework – to a distributed cloud infrastructure. We propose a novel architecture for distributed and incremental queries, and conduct experiments to demonstrate that


, our prototype system, can scale up from a single workstation to a cluster that can handle very large models and complex incremental queries efficiently.

Gábor Szárnyas, Benedek Izsó, István Ráth, Dénes Harmath, Gábor Bergmann, Dániel Varró

Translating OCL to Graph Patterns

Model-driven tools use model queries for many purposes, including validation of well-formedness rules and specification of derived features. The majority of declarative model query corpus available in industry appears to use the OCL language. Graph pattern based queries, however, would have a number of advantages due to their more abstract specification, such as performance improvements through advanced query evaluation techniques. As query performance can be a key issue with large models, evaluating graph patterns instead of OCL queries could be useful in practice.

The current paper presents an automatic mapping from a large sublanguage of OCL expressions to equivalent graph patterns in the dialect of


. Validation of benefits is carried out by performance measurements according to an existing benchmark.

Gábor Bergmann


Weitere Informationen

Premium Partner