Model driven engineering languages and systems 11th international conference, MoDELS 2008, toulouse, france, september 28 oc

Lecture Notes in Computer Science
Commenced Publication in 1973
Founding and Former Series Editors:
Gerhard Goos, Juris Hartmanis, and Jan van Leeuwen

Editorial Board
David Hutchison
Lancaster University, UK
Takeo Kanade
Carnegie Mellon University, Pittsburgh, PA, USA
Josef Kittler
University of Surrey, Guildford, UK
Jon M. Kleinberg
Cornell University, Ithaca, NY, USA
Alfred Kobsa
University of California, Irvine, CA, USA
Friedemann Mattern
ETH Zurich, Switzerland
John C. Mitchell
Stanford University, CA, USA
Moni Naor
Weizmann Institute of Science, Rehovot, Israel
Oscar Nierstrasz
University of Bern, Switzerland
C. Pandu Rangan
Indian Institute of Technology, Madras, India
Bernhard Steffen
University of Dortmund, Germany
Madhu Sudan
Massachusetts Institute of Technology, MA, USA
Demetri Terzopoulos

University of California, Los Angeles, CA, USA
Doug Tygar
University of California, Berkeley, CA, USA
Gerhard Weikum
Max-Planck Institute of Computer Science, Saarbruecken, Germany

5301


Krzysztof Czarnecki Ileana Ober
Jean-Michel Bruel Axel Uhl
Markus Völter (Eds.)

Model Driven
Engineering Languages
and Systems
11th International Conference, MoDELS 2008
Toulouse, France, September 28 - October 3, 2008
Proceedings

13


Volume Editors
Krzysztof Czarnecki
University of Waterloo
Department of Electrical and Computer Engineering
200 University Ave., West Waterloo, ON, N2L 3G1, Canada
E-mail:
Ileana Ober

Université Paul Sabatier, IRIT - MACAO
118, route de Narbonne, 31062 Toulouse, France
E-mail:
Jean-Michel Bruel
Université de Pau et des Pays de l’Adour
Département Informatique
Av. de l’Université, B.P. 1155, 64013 Pau, France
E-mail:
Axel Uhl
SAP AG, 69190 Walldorf, Germany
E-mail:
Markus Völter
Independent Consultant
Grabenstrasse 4, 73033 Göppingen, Germany
E-mail:

Library of Congress Control Number: 2008935624
CR Subject Classification (1998): D.2, D.3, K.6, I.6
LNCS Sublibrary: SL 2 – Programming and Software Engineering
ISSN
ISBN-10
ISBN-13

0302-9743
3-540-87874-2 Springer Berlin Heidelberg New York
978-3-540-87874-2 Springer Berlin Heidelberg New York

This work is subject to copyright. All rights are reserved, whether the whole or part of the material is
concerned, specifically the rights of translation, reprinting, re-use of illustrations, recitation, broadcasting,
reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication

or parts thereof is permitted only under the provisions of the German Copyright Law of September 9, 1965,
in its current version, and permission for use must always be obtained from Springer. Violations are liable
to prosecution under the German Copyright Law.
Springer is a part of Springer Science+Business Media
springer.com
© Springer-Verlag Berlin Heidelberg 2008
Printed in Germany
Typesetting: Camera-ready by author, data conversion by Scientific Publishing Services, Chennai, India
Printed on acid-free paper
SPIN: 12534548
06/3180
543210


Preface

MODELS 2008 was the 11th edition of the series of conferences on Model-Driven
Engineering Languages and Systems. The conference was held in Toulouse,
France, during the week of September 28 to October 3, 2008. The local arrangements were provided by the Institut de Recherche en Informatique de Toulouse
(IRIT).
The conference program included three keynote presentations, technical paper presentations, two panels, and several workshops and tutorials. The invited
keynote speakers were Don Batory (University of Texas, USA), Jeff Kramer
(Imperial College London, UK), and Patrick Rauhut (Airbus, Germany).
This volume contains the final versions of the papers accepted for presentation
at the conference. The papers cover a wide range of topics from the field including
model transformation, model management, domain-specific modeling, modeling
language semantics, model analysis, and applications.
We received a record number of 271 full paper submissions from 40 different
countries. Of these, 43 papers were submitted by authors from more than one
country. The top three countries submitting papers were France (40), Germany

(38), and Canada (24). A total of 58 papers were accepted for inclusion in the
proceedings. The acceptance rate was therefore 21%, which is somewhat lower
than those of the previous MODELS conferences.
At least three Program Committee or Expert Reviewer Panel members reviewed each paper. Reviewing was thorough, and most authors received detailed
comments on their submissions. Conflicts of interest were taken very seriously.
No-one participated in any way in the decision process of any paper where a conflict of interest was identified. In particular, PC members who submitted papers
did not have access to information concerning the reviews of their papers.
We would like to thank everyone who submitted papers as well as proposals
for workshops and tutorials. We would also like to thank the large number of
volunteers who contributed to the success of the conference. Richard van de
Stadt deserves special thanks for his prompt and gracious service in supporting
special requests for CyberChairPRO, the conference management system used
to manage papers submissions and the virtual PC meeting. Finally, we would
like to thank our sponsors, ACM and IEEE Computer Society, for their support
of the MODELS 2008 conference.
October 2008

Krzysztof Czarnecki
Ileana Ober
Jean-Michel Bruel
Axel Uhl
Markus V¨
olter


Organization

Conference Chairs
Ileana Ober (IRIT, France)
Jean-Michel Bruel (LIUPPA, France)

Program Chair
Krzysztof Czarnecki (University of Waterloo, Canada)

Experience Track Chairs
Axel Uhl (SAP, Germany)
Markus V¨
olter (Independent Consultant, Germany)

Technological Track Chair
Pascal Roques (Valtech Training, France)

Workshop Chair
Michel Chaudron (Technical University Eindhoven and Leiden University,
The Netherlands)

Tutorial Chair
Xavier Blanc (University Pierre et Marie Curie, France)

Panel Chair
Sudipto Ghosh (Colorado State University, USA)

Research Project Symposium Chair
Iulian Ober (Toulouse University, France)

Doctoral Symposium Chair
Alexander Pretschner (ETH Zurich, Switzerland)


VIII

Organization

Educators’ Symposium Chair
´
Michal Smialek
(Warsaw University of Technology, Poland)

Publicity Chair
Benoit Baudry (IRISA, France)

Web Chair
Nicolas Belloir (LIUPPA, France)

Organizing Committee
Jean-Paul Bodeveix (France)
Pierre Bazex (France)
Nicolas Belloir (France)
Agusti Canals (France)
Maura Cerioli (Italy)
Xavier Cr´egut (France)
Patrick Farail (France)

Louis F´eraud (France)
Geri Georg (USA)
Herv´e Leblanc (France)
Michel Lemoine (France)
Thierry Millan (France)
Mario Paludetto (France)
Christian Percebois (France)

Program Committee
Jo˜
ao Ara´
ujo (Portugal)
Uwe Aßmann (Germany)
Benoit Baudry (France)
Xavier Blanc (France)
Jean B´ezivin (France)
Paulo Borba (Brazil)
Lionel Briand (Norway)
Betty Cheng (USA)
Shigeru Chiba (Japan)
Krzysztof Czarnecki (Canada)
Juergen Dingel (Canada)
Gregor Engels (Germany)
Alexander Egyed (Austria)
Jean-Marie Favre (France)
Bernd Fischer (UK)
Robert France (USA)
Harald Gall (Switzerland)
Dragan Gaˇsevi´c (Canada)
Geri Georg (USA)

Holger Giese (Germany)
Tudor Girba (Switzerland)
Martin Gogolla (Germany)
Aniruddha Gokhale (USA)
Orla Greevy (Switzerland)
Paul Gr¨

unbacher (Austria)
John Grundy (New Zealand)
Øystein Haugen (Norway)
Simon Helsen (Germany)
Robert Hirschfeld (Germany)
Heinrich Hussmann (Germany)
Jean-Marc J´ez´equel (France)
Gabor Karsai (USA)
Jana Koehler (Switzerland)
Rainer Koschke (Germany)
Thomas K¨
uhne (New Zealand)
Vinay Kulkarni (India)
Jochen K¨
uster (Switzerland)
Ralf L¨
ammel (Germany)


Organization

Michele Lanza (Switzerland)
Michael Lawley (Australia)
Timothy C. Lethbridge (Canada)
Ed Merks (Canada)
Birger Møller-Pedersen (Norway)
Ana Moreira (Portugal)
Pierre-Alain Muller (France)
Richard Paige (UK)
Alexander Pretschner (Switzerland)

Gianna Reggio (Italy)
Bernhard Rumpe (Germany)
Andy Sch¨
urr (Germany)
Bran Selic (Canada)
Perdita Stevens (UK)

Eleni Stroulia (Canada)
Gabriele Taentzer (Germany)
Juha-Pekka Tolvanen (Finland)
Laurence Tratt (UK)
Axel Uhl (Germany)
Hans Vangheluwe (Canada)
D´
aniel Varr´
o (Hungary)
Eelco Visser (The Netherlands)
Markus V¨
olter (Germany)
Andrzej Wasowski (Denmark)
Thomas Weigert (USA)
Jon Whittle (UK)

Expert Reviewer Panel
Aditya Agrawal (USA)
Jean-Michel Bruel (France)
Nancy Day (Canada)
Sebastian Fischmeister (Canada)
S´ebastien G´erard (France)
Jeff Gray (USA)

Ileana Ober (France)
Kasper Østerbye (Denmark)
Awais Rashid (UK)
Andreas Rummler (Germany)
Peter Sesoft (Denmark)

Steering Committee
Thomas Baar (Switzerland)
Jean B´ezivin (France)
Lionel Briand (Norway)
Steve Cook (UK)
Gregor Engels (Germany)
Andy Evans (UK)
Robert France (USA)
Geri Georg (USA)
Martin Gogolla (Germany)
Heinrich Hussmann (Germany)
Jean-Marc J´ez´equel (France)
Stuart Kent (UK)

Cris Kobryn (USA)
Ana Moreira (Portugal)
Pierre-Alain Muller (France)
Oscar Nierstrasz (Switzerland)
Gianna Reggio (Italy)
David Rosenblum (UK)
Bernhard Rumpe (Germany)
Douglas C. Schmidt (USA)
Bran Selic (Canada)

Perdita Stevens (UK)
Jon Whittle (Chair; USA)

Sponsors
ACM Special Interest Group on Software Engineering
(www.sigsoft.org)
IEEE Computer Society
(www.computer.org)

IX


X

Organization

Additional Reviewers
Vasco Amaral
Carsten Amelunxen
Malte Appeltauer
Egidio Astesiano
Richard Atterer
Andrej Bachmann
Omar Bahy Badreldin
Florence Balagtas-Fernandez
Andr´
as Balogh
Jan-Christopher Bals
Olivier Barais
Bruno Barroca

Thiago T. Bartolomei
Dominikus Baur
Basil Becker
Nelly Bencomo
Alexej Beresnev
Rodrigo Bonifacio
Phil Brooke
Erwan Brottier
Achim D. Brucker
Fabian Buettner
Sebastian Cech
Maura Cerioli
Franck Chauvel
Dan Chiorean
Fabian Christ
Peter J. Clarke
Michelle Crane
Arnaud Cuccuru
Akshay Dabholkar
Duc-Hanh Dang
Vegard Dehlen
Romain Delamare
Deepak Dhungana
Zinovy Diskin
Nikos Drivalos
Cedric Dumoulin
Huascar Espinoza
Johan Fabry
Fernando Castor Filho
Franck Fleurey

Alexander Foerster
Fr´ed´eric Fondement
Istv´an Forg´
acs
Andrew Forward
L´aszl´o G¨
onczy
Christian Gerth
Giacomo Ghezzi
Thomas Goldschmidt
Pieter Van Gorp
Emanuel Grant
Danny Groenewegen
Hans Groenniger
Iris Groher
Lindsay Groves
Roy Grønmo
Thomas Gschwind
Baris G¨
uldali
Ulrich Hannemann
Michael Haupt
Zef Hemel
Christoph Herrmann
Anders Hessellund
Thomas Hettel
Mark Hibberd
Stephan Hildebrandt
Otmar Hilliges

Berthold Hoffmann
Jippe Holwerda
´
Akos
Horv´
ath
Michael Jackson
Mikol´
aˇs Janota
Cedric Jeanneret
Jendrik Johannes
Fr´ed´eric Jouault
Christophe Jouvray
Stefan Jurack
Markus Kaiser
Sven Karol
Lennart C. L. Kats
Nima Kaviani
Amogh Kavimandan
Dae-Kyoo Kim


Organization

Felix Klar
Florian Klein
Renate Klempien-Hinrichs
Patrick Knab
Imre Kocsis
Dimitrios Kolovos

M´
at´e Kov´
acs
Holger Krahn
Ingolf Krueger
Mirco Kuhlmann
Uir´
a Kulesza
Sabine Kuske
Elodie Legros
L´aszl´o Lengyel
Tiham´er Levendovszky
Hongzhi Liang
Jens Lincke
Alexander De Luca
Christoph Lueth
Mass Soldal Lund
Tiago Massoni
Matthew J. McGill
Tom Mens
Kirsten Mewes
Gergely Mezei
Milan Milanovic
Dragan Milicev
Parastoo Mohagheghi
Brice Morin
Pieter Mosterman
Jean-Marie Mottu
Patrick Mukherjee
Freddy Munoz

Gunter Mussbacher
Stefan Neumann
James Noble
Jon Oldevik
Sebastian Oster
Cesare Pautasso
Luis Pedro
Gilles Perrouin
Claas Pinkernell
Eduardo Piveta
Fiona Polack

Ernesto Posse
Christopher Power
Rick Rabiser
Ansgar Radermacher
Oliver Radfelder
Y. Raghu Reddy
Dirk Reiss
Marko Ribaric
M´
arcio de Medeiros Ribeiro
Filippo Ricca
Sebastian Richly
Matteo Risoldi
David Roethlisberger
Jens Rommel
Louis Rose
Nilabja Roy
Suman Roychoudhury

Ahmad Saifan
Yavuz Sancar
Tim Schattkowsky
Marvin Schulze-Quester
Andreas Seibel
Sagar Sen
Steven She
Carla Silva
Karsten Sohr
Arnor Solberg
Christian Soltenborn
Jean-Sebastien Sottet
Jim Steel
Mark Stein
Matthew Stephan
Gerson Sunye
Eugene Syriani
D´
aniel T´
oth
Safouan Taha
Gergely Varr´o
Sander Vermolen
Hendrik Voigt
Steven V¨
olkel
Arild Waaler
Ksenia Wahler
Michael Wahler
Ingo Weisemoeller

XI


XII

Organization

Christian Wende
Bernhard Westfechtel
Gerd Wierse
Michael Wuersch
Jochen Wuttke

Andreas W¨
ubbeke
Vadim Zaytsev
Olaf Zimmermann
Steffen Zschaler


Table of Contents

Keynote I
The Objects and Arrows of Computational Design . . . . . . . . . . . . . . . . . . .
Don Batory, Maider Azanza, and Jo˜
ao Saraiva

1

Model Transformation: Foundations
Algebraic Models for Bidirectional Model Synchronization . . . . . . . . . . . . .
Zinovy Diskin

21

An Invariant-Based Method for the Analysis of Declarative
Model-to-Model Transformations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Jordi Cabot, Robert Claris´
o, Esther Guerra, and Juan de Lara

37

Precise Semantics of EMF Model Transformations by Graph
Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Enrico Biermann, Claudia Ermel, and Gabriele Taentzer

53

Requirements Modeling
A Formal Metamodel for Problem Frames . . . . . . . . . . . . . . . . . . . . . . . . . . .
Denis Hatebur, Maritta Heisel, and Holger Schmidt
Visualization of Use Cases through Automatically Generated Activity
Diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Javier J. Guti´errez, Cl´ementine Nebut, Mar´ıa J. Escalona,
Manuel Mej´ıas, and Isabel M. Ramos
Requirements Modeling and Validation Using Bi-layer Use Case
Descriptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Avik Sinha, Matthew Kaplan, Amit Paradkar, and Clay Williams

68

83

97

Domain-Specific Modeling
WebWorkFlow: An Object-Oriented Workflow Modeling Language for
Web Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zef Hemel, Ruben Verhaaf, and Eelco Visser
The Future of Train Signaling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Andreas Svendsen, Gøran K. Olsen, Jan Endresen, Thomas Moen,
Erik Carlson, Kjell-Joar Alme, and Øystein Haugen

113
128


XIV

Table of Contents

NAOMI – An Experimental Platform for Multi–modeling . . . . . . . . . . . . .
Trip Denton, Edward Jones, Srini Srinivasan, Ken Owens, and
Richard W. Buskens

143

Keynote II
Abstraction and Modelling—A Complementary Partnership

(Abstract) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Jeff Kramer

158

Model Transformation: Techniques
Model Transformation as an Optimization Problem . . . . . . . . . . . . . . . . . .
Marouane Kessentini, Houari Sahraoui, and Mounir Boukadoum

159

Example-Based Program Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Romain Robbes and Michele Lanza

174

Detecting Patterns of Poor Design Solutions Using Constraint
Propagation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ghizlane El-Boussaidi and Hafedh Mili

189

Composition and Analysis of Behavioral Models
A General Approach for Scenario Integration . . . . . . . . . . . . . . . . . . . . . . . .
Hongzhi Liang, Zinovy Diskin, Juergen Dingel, and Ernesto Posse
Behavioral Modelling and Composition of Object Slices Using Event
Observation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Iulian Ober, Bernard Coulette, and Younes Lakhrissi
Scenario-Based Static Analysis of UML Class Models . . . . . . . . . . . . . . . . .
Lijun Yu, Robert B. France, and Indrakshi Ray

204

219
234

Model Comprehension
Constructing Models with the Human-Usable Textual Notation . . . . . . . .
Louis M. Rose, Richard F. Paige, Dimitrios S. Kolovos, and
Fiona A.C. Polack

249

X3D-UML: 3D UML State Machine Diagrams . . . . . . . . . . . . . . . . . . . . . . .
Paul McIntosh, Margaret Hamilton, and Ron van Schyndel

264

Assessing the Influence of Stereotypes on the Comprehension of UML
Sequence Diagrams: A Controlled Experiment . . . . . . . . . . . . . . . . . . . . . . .
Marcela Genero, Jos´e A. Cruz-Lemus, Danilo Caivano,
Silvia Abrah˜
ao, Emilio Insfran, and Jos´e A. Cars´ı

280


Table of Contents

XV

Keynote III
3D Parametric Models for Aeroplanes—From Idea to Design
(Abstract) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Patrick Rauhut

295

Model Management
MOOGLE: A Model Search Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Daniel Lucr´edio, Renata P. de M. Fortes, and Jon Whittle

296

Managing Model Conflicts in Distributed Development . . . . . . . . . . . . . . .
Antonio Cicchetti, Davide Di Ruscio, and Alfonso Pierantonio

311

Metamodel Matching for Automatic Model Transformation
Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Jean-R´emy Falleri, Marianne Huchard, Mathieu Lafourcade, and
Cl´ementine Nebut

326

Behavioral Conformance and Refinement
Sufficient Criteria for Consistent Behavior Modeling with Refined
Activity Diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Stefan Jurack, Leen Lambers, Katharina Mehner, and

Gabriele Taentzer
Implementation of the Conformance Relation for Incremental
Development of Behavioural Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Hong-Viet Luong, Thomas Lambolais, and Anne-Lise Courbis
A Model-Based Framework for Statically and Dynamically Checking
Component Interactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Guillaume Waignier, Prawee Sriplakich,
Anne-Fran¸coise Le Meur, and Laurence Duchien

341

356

371

Metamodeling and Modularity
Formal Definition of MOF 2.0 Metamodel Components and
Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ingo Weisem¨
oller and Andy Sch¨
urr
Interfaces and Metainterfaces for Models and Metamodels . . . . . . . . . . . . .
Anders Hessellund and Andrzej Wasowski
Model&Metamodel, Metadata and Document Repository for Software
and Data Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Nikola Milanovic, Ralf Kutsche, Timo Baum, Mario Cartsburg,
Hatice Elmasg¨
unes, Marco Pohl, and J¨
urgen Widiker

386
401

416


XVI

Table of Contents

Constraints
Model Construction with External Constraints: An Interactive Journey
from Semantics to Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mikol´
aˇs Janota, Victoria Kuzina, and Andrzej Wasowski

431

A Benchmark for OCL Engine Accuracy, Determinateness, and
Efficiency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Martin Gogolla, Mirco Kuhlmann, and Fabian B¨
uttner

446

Contrary-to-Duties Constraints: From UML to Relational Model . . . . . . .
Pedro Nogueira Ramos

460

Model Analysis
A UML/SPT Model Analysis Methodology for Concurrent Systems
Based on Genetic Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Marwa Shousha, Lionel Briand, and Yvan Labiche

475

Integrating Performance Analysis in the Model Driven Development of
Software Product Lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rasha Tawhid and Dorina Petriu

490

A Model-Driven Measurement Approach . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Martin Monperrus, Jean-Marc J´ez´equel, Jo¨el Champeau, and
Brigitte Hoeltzener

505

Service-Oriented Architectures
Specifying Service Composition Using UML 2.x and Composition
Policies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Judith E.Y. Rossebø and Ragnhild Kobro Runde
A Model-Based Framework for Security Policy Specification,
Deployment and Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tejeddine Mouelhi, Franck Fleurey, Benoit Baudry, and
Yves Le Traon
A Pattern Language Verifier for Web-Based Enterprise Applications . . . .
Bahman Zamani, Sahar Kayhani, and Greg Butler

520

537

553

Adaptive and Autonomic Systems
Automatically Generating Behavioral Models of Adaptive Systems to
Address Uncertainty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Heather J. Goldsby and Betty H.C. Cheng

568


Table of Contents

Autonomic Management Policy Specification: From UML to DSML . . . .
Benoˆıt Combemale, Laurent Broto, Xavier Cr´egut,
Michel Dayd´e, and Daniel Hagimont

XVII

584

Empirical Studies
Empirical Analysis of the Relation between Level of Detail in UML
Models and Defect Density . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ariadi Nugroho, Bas Flaton, and Michel R.V. Chaudron

600

An Empirical Investigation on Dynamic Modeling in Requirements
Engineering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Carmine Gravino, Giuseppe Scanniello, and Genoveffa Tortora

615

Evolution and Reverse Engineering
Heterogeneous Coupled Evolution of Software Languages . . . . . . . . . . . . . .
Sander Vermolen and Eelco Visser
Automatability of Coupled Evolution of Metamodels and Models in
Practice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Markus Herrmannsdoerfer, Sebastian Benz, and Elmar Juergens
Enriching Reverse Engineering with Annotations . . . . . . . . . . . . . . . . . . . . .
Andrea Br¨
uhlmann, Tudor Gˆırba, Orla Greevy, and Oscar Nierstrasz

630

645
660

Modeling Language Semantics
Towards a Formal Account of a Foundational Subset for Executable
UML Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Michelle L. Crane and Juergen Dingel

675

A Lightweight Approach for Defining the Formal Semantics of a

Modeling Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pierre Kelsen and Qin Ma

690

Semantically Configurable Code Generation . . . . . . . . . . . . . . . . . . . . . . . . .
Adam Prout, Joanne M. Atlee, Nancy A. Day, and Pourya Shaker

705

Dependability Analysis and Testing
Safety Hazard Identification by Misuse Cases: Experimental
Comparison of Text and Diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tor St˚
alhane and Guttorm Sindre
Adding Dependability Analysis Capabilities to the MARTE Profile . . . . .
Simona Bernardi, Jos´e Merseguer, and Dorina C. Petriu

721
736


XVIII

Table of Contents

Visual ScatterUnit: A Visual Model-Driven Testing Framework of
Wireless Sensor Networks Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mohammad Al Saad, Nicolai Kamenzky, and Jochen Schiller

751

Aspect-Oriented Modeling
Aspect-Oriented Model Weaving Beyond Model Composition and
Model Transformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pablo S´
anchez, Lidia Fuentes, Dominik Stein,
Stefan Hanenberg, and Rainer Unland
An Aspect-Oriented and Model-Driven Approach for Managing
Dynamic Variability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Brice Morin, Franck Fleurey, Nelly Bencomo, Jean-Marc J´ez´equel,
Arnor Solberg, Vegard Dehlen, and Gordon Blair
Managing Variability Complexity in Aspect-Oriented Modeling . . . . . . . .
Brice Morin, Gilles Vanwormhoudt, Philippe Lahire, Alban Gaignard,
Olivier Barais, and Jean-Marc J´ez´equel

766

782

797

Structural Modeling
Mapping the UML2 Semantics of Associations to a Java Code
Generation Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dominik Gessenharter

813

Meaningful Composite Structures: On the Semantics of Ports in

UML2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arnaud Cuccuru, S´ebastien G´erard, and Ansgar Radermacher

828

A Systematic Approach to Connectors in a Multi-level Modeling
Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Matthias Gutheil, Bastian Kennel, and Colin Atkinson

843

Embedded Systems
Model-Based Quality Assurance of Automotive Software . . . . . . . . . . . . . .
Jan J¨
urjens, Daniel Reiß, and David Trachtenherz

858

Ontology Guided Evolution of Complex Embedded Systems Projects in
the Direction of MDA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lars Pareto, Miroslaw Staron, and Peter Eriksson

874

General Mode Controller for Software on Artificial Satellite with
Model-Based Validation Tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Toshihiro Obata and Teiichiro Inoue

889

Workshops, Symposia, Tutorials, and Panels
Workshops at MODELS 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Michel R.V. Chaudron

896


Table of Contents

XIX

Educators Symposium at MODELS 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . .
´
Michal Smialek

906

Doctoral Symposium at MODELS 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Alexander Pretschner

908

Tutorials at MODELS 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Xavier Blanc

910

Panels at MODELS 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sudipto Ghosh

916

Author Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

919


The Objects and Arrows of Computational Design
Don Batory1, Maider Azanza2, and João Saraiva3
1

University of Texas at Austin, Austin, Texas, USA

2
University of the Basque Country, San Sebastian, Spain

3
Universidade do Minho, Campus de Gualtar, Braga, Portugal


Abstract. Computational Design (CD) is a paradigm where both program design and program synthesis are computations. CD merges Model Driven Engineering (MDE) which synthesizes programs by transforming models, with
Software Product Lines (SPL) where programs are synthesized by composing
transformations called features. In this paper, basic relationships between MDE
and SPL are explored using the language of modern mathematics.
Note: Although jointly authored, this paper is written as presented by Batory in
his MODELS 2008 keynote.
Keywords: Software product lines, model driven engineering, categories.

1 Introduction
The future of program design and development lies in automation — the mechanization of repetitive tasks to free programmers from mundane activities so that they can

tackle more creative problems. We are entering the age of Computational Design
(CD), where both program design and program synthesis are computations [39]. By
design, I mean “what are the steps to create a program that meets a specification” (i.e.,
do this, then this, etc.). Such a script is called a metaprogram. By synthesis, I mean
“execute these steps to produce the program”. This is metaprogram execution.
At the forefront of Computational Design are two complementary but different
technologies: Model Driven Engineering (MDE) and Software Product Lines (SPL).
These technologies have much in common and may soon be hard to distinguish. But
abstractly for this paper, I will refer to “pure” MDE as defining high-level models of
an application, and transforming these models into low-level artifacts, such as executables. “Pure” MDE is a general paradigm for program synthesis. In contrast, I will
refer to “pure” SPL as a domain-specific paradigm for program synthesis. It exploits
the knowledge of problems in a particular domain, tried-and-tested solutions to these
problems, and the desire to automate the construction of such programs given this
knowledge. Both “pure” MDE and “pure” SPL are synergistic: the strengths of one
are the weaknesses of the other. MDE and SPL are clearly not mutually-disjoint technologies, but I will present their strengths as such here.
K. Czarnecki et al. (Eds.): MoDELS 2008, LNCS 5301, pp. 1–20, 2008.
© Springer-Verlag Berlin Heidelberg 2008


2

D. Batory, M. Azanza, and J. Saraiva

In a prior lifetime, I was a database researcher. My introduction to program synthesis was relational query optimization (RQO) [32]. The design of a query evaluation
program was defined by a composition of relational algebra operations, a.k.a. a relational algebra expression. Expressions were optimized by applying algebraic identities called rewrite rules. Applying rules was the task of a query optimizer. It took me
years to appreciate the significance and generality of RQO: it is a compositional paradigm for program synthesis and is a classic example of Computational Design. RQO
fundamentally shaped my view of automated software development more than any
software engineering course (in the 1980s and maybe even now) could have.
My research focusses on SPLs, where the goal is to design and synthesize any
member of a family of related programs automatically from declarative specifications.

The thrust of my early work was on language and tool support for SPLs. More recently, my interest shifted to elucidate the foundational concepts of SPL and MDE.
Early on, I needed a simple modeling language to express program design and synthesis as a computation. I discovered that modern mathematics fit the bill.
Here’s the reason: software engineers define structures called programs and use
tools to transform, manipulate, and analyze them. Object orientation uses methods,
classes, and packages to structure programs. Compilers transform source structures
into bytecode structures. Refactoring tools transform source structures into other
source structures, and metamodels of MDE define the allowable structures of model
instances: transformations map metamodel instances to instances of other metamodels
for purposes of analysis and synthesis. Software engineering is replete with such examples.
Mathematics is the science of structures and their relationships. I use mathematics
as an informal modeling language (not as a formal model) to explain Computational
Design. Certainly I claim no contributions to mathematics, but I do lay claim to exposing its relevance in informal modeling in SPLs. The foundation of my work rests
on ancient ideas: that programs are data or values, transformations map programs to
programs, and operators map transformations to transformations [11]. This orientation
naturally lead me to MDE, with its emphasis on transformations.
Table 1. MDE, SPL, and Category Theory Terminology
Paradigm

Object

Point

MDE

metamodel

model

transformation

program

feature

SPL

Arrow

The goal of this paper is to expose a set of concepts on which MDE, SPL, and
Computation Design are founded. Although the concepts come from category theory
[25][30], a general theory of mathematical structures and their relationships, this paper is aimed at practitioners who do not have a mathematical background. I show how
MDE and SPL ideas map to categorical concepts, and throughout this paper, I explain
the benefits in making a connection. Table 1 summarizes the terminological correspondence. Basic concepts of category theory are in use today, but I suspect members
of the SPL and MDE communities may not appreciate them. Also, as this conference
is about modeling, it is worth noting that mathematicians can be superb modelers, and


The Objects and Arrows of Computational Design

3

leveraging their ideas is largely what this paper is about. I begin by explaining a simple relationship between MDE and categories.

2 MDE and Categories
In category theory, an ob- (a)
o b je c t
(b) m e ta m o d e l
cone of
cone of
ject is a domain of points

o b je c t
m e ta m o d e l
in s ta n c e s
in s ta n c e s
(there does not seem to be a
standard name for object
instances — I follow Lawp
m
p
m
vere’s text and use ‘points’
p
m
p
m
1
[25]). In Figure 1a, an p o in ts
m o d e ls
object is depicted with its
Fig. 1. Objects as Domains of points
domain of points, shown as
a cone of instances. This
diagram is familiar to the
MDE community as a metamodel and its model instances (Fig.1b). “Pure” MDE focuses on a particular technology implementation (e.g., MOF, Ecore) of metamodels
and their instances. However, the ideas of objects and instances are more general.
This observation has been noted by others, e.g., Bézivin’s technical spaces [24] and
GROVE [34]. So one can think of a Java “object” whose instances are Java programs,
a bytecode “object” whose instances are Java bytecode files, an XML “object” (XML
schemata) whose instances are XML files, and so on.
1

2

3

1

4

2

3

4

Recursion is fundamental to category theory: a point can be an object. Fig. 2a depicts
such a situation, which readers will recognize as isomorphic to the standard multilevel MOF architecture of Fig.2b:
object

m eta-m etam odel

(a)

(b)
m eta
m odels
o2

o1

p1

p2

p3

p4

p o in ts

p5

mm2
mm3

mm1

o4

o3

p6

m1 m2 m3

mm4

m4 m5 m6

m o d els

Fig. 2. Three-Level MOF Architecture

The MOF architecture is not interesting in category theory without arrows. An arrow is a map or function or morphism between objects, and whose implementation is
unspecified.2 Figure 3a shows an external diagram [25] that displays two objects, S
1

I recommend Pierce’s text on category theory [30] with concrete examples in [12] as illustrations; Lawvere’s text is also quite accessible [25].
2
A morphism is not necessarily a function; it can express a relationship, e.g., ≥ .


4

D. Batory, M. Azanza, and J. Saraiva

and J, and an arrow A that maps each point of S to a point in J. (Arrows are always
total, not partial, maps [30]). Figure 3b shows a corresponding internal diagram that
exposes the points of every object of an external diagram and the mapping relationships among points. In general, there can be any number of arrows that connect objects; Figure 3c shows an arrow B that is different from A.

(a)
(b)

A

S

s1

s2

j2
j3

J

(c)

J

j1

s3

A

S

s1

j4

S

J

B

s2

j1

s3

j2
j3

j4

Fig. 3. External and Internal Diagrams

In this paper, I use the following terminology: an arrow is a mapping relationship,
a transformation is an implementation of an arrow as expressed by an MDE transformation language (e.g., QVT [29], ATL [21], RubyTL [16], GReAT [1]), and a tool is
any other (e.g., Java, Python) implementation of an arrow.
Now consider the following example: the external diagram of Fig. 4 shows that a
message sequence chart (MSC) can be mapped to a state chart (SC) via a model-tomodel transformation (M2MX). A state chart can be mapped to a Java program by a
model-to-text transformation (M2TX). And a Java program is mapped to bytecode by
the javac tool. Each arrow is realized by a distinct technology. In addition to these
arrows, there are also identity arrows for each object.

MSC

M2MX

SC

M2TX

Java

javac

ByteCode

Fig. 4. Another External Diagram

There does not seem to be a standard name for such diagrams in MDE. Common
names are tool chain diagrams [29] and megamodels [14] (both of which have slightly
different graphical notations). Fig. 4 is also isomorphic to a UML class diagram,
where metamodels are classes, transformations are methods, and fields of classes are
private or hidden [10][34]. External diagrams are also standard depictions of categories. A category is a collection of objects and arrows, where each object has an identity arrow (i.e., identity transformation). Fig. 4 is an external diagram of a category of
four objects and three non-identity arrows.
Besides objects and arrows, categories have the following properties [25][30]:
•

Arrows are composable: given arrows f:A→B and g:B→C, there is a composite
arrow g•f:A→C.


The Objects and Arrows of Computational Design

•
•

5

Composition is associative: given arrows f:A→B, g:B→C, and h:C→D (with A, B,
C, and D not necessarily distinct), h•(g•f) = (h•g)•f.
For each object A, there is an identity arrow idA:A→A such that for any arrow
f:A→B, idB•f = f and f•idA=f.

Identity and composed arrows are often omitted from external diagrams.
The above properties allow us to infer that there is an arrow T:MSC→ByteCode that
maps message sequence charts to Java bytecodes, where T=javac•MT2X•M2MX (T is not
displayed in Fig. 4). In general, there needs to be tool support for these abstractions,
so that all arrows, regardless on how they are implemented, can be treated uniformly.
GROVE [34] and UniTI [37] are steps in the right direction.
Category theory defines arrows that map
one input object to one output object. But in
O123
O45
F
MDE, it is common in model weaving to map
projection
multiple models as input and produce multiarrows
ple models as output [15]. Category theory
O4 O5
has an elegant way to express this. The idea is O1 O2 O3
to define a tuple of objects (called a product
Fig. 5. Products of Objects
of objects [25][30]), and this tuple is itself an
object. Projection arrows are defined so that
each component of a tuple can be extracted. Fig. 5 depicts an arrow F:[O1,O2,O3]→
[O4,O5] which maps a 3-tuple of objects to a pair of objects, along with projection arrows.
Now, let’s look at Fig. 6, which depicts an internal diagram of Fig. 4. Although
only one point is shown for each object, the relationships between these points
(m1,s1,j1,b1) is also a category, sometimes called a trivial category, i.e., a category
where each object represents a domain with a single point.

MSC

m1

M 2M X

SC

s1

M 2T X

Java

j1

javac

B yteCode

b1

Fig. 6. An Internal Diagram of Fig. 4

In general, categories lie at the heart of MDE and can be found at all levels in a
MDE architecture. Category theory provides an elegant set of ideas to express
transformation relationships among objects that arise in MDE. The ideas are straightforward, if not familiar and have an elementary benefit: they may provide a clean
foundation for MDE (e.g., such as a language and terminology to express MDE Computational Designs). A nice example of a formal use of categories in MDE is [19].
Now let’s look at the connection between product lines and categories.

6

D. Batory, M. Azanza, and J. Saraiva

3 SPL and Categories
A software product line is a set of similar programs. Programs are constructed from
features, which are increments in program functionality that customers use to distinguish one program from another. For example, program P is constructed from program G by adding feature F. This is expressed by modeling F as a function: P=F(G).
The code of a product line of calculators is shown in Fig. 7. Associated with each
line of code is a tag, which indicates the feature that adds that line. This makes it easy
to build a preprocessor that receives as input the names of the desired features and
strips off the code belonging to unneeded features. As can be imagined, this approach
is brittle for problems of larger scale and complexity. Nevertheless, we use it as a reference to define what changes occur when a feature is added to a program.
The first program P1 of
the calculator SPL defines
base class calculator {
a calculator class and its
int result;
base
gui class. The base calcuvoid add( int x ) { result=+x; }
base
lator only allows numbers
void sub( int x ) { result=-x; }
sub
to be added. The second
base }
program P2=sub(P1), exbase class gui {
tends the base with a subJButton add = new JButton("add");
base
traction operation (both the
JButton sub = new JButton("sub");

sub
calculator and gui clasJButton form = new JButton("format");
form
ses are updated). The efvoid initGui() {
base
fect of the sub feature is to
ContentPane.add( add );
base
add new methods and new
ContentPane.add( sub );
sub
fields to existing classes,
ContentPane.add( form );
form
and to extend existing met}
base
hods with additional code.
void initListeners() {
More generally, features
base
add.addActionListener(...);
can add new classes and
base
sub.addActionListener(...);
sub
packages as well. The third
form.addActionListener(...);
form
program
P3=format(P2)

}
base
adds an output formatting
form
capability to a calculator,
void formatResultString() {...}
base }
where again new methods
and new fields are added,
Fig. 7. Complete Code of the calculator SPL
and existing methods are
extended. A fourth program, P4=format(P1), extends the base program with the format feature. One can push these ideas further, and
say the base program is itself a feature, which extends the empty program 0, i.e.,
P1=base(0). Feature base adds new classes (the base calculator class and the base
gui class) to 0.
These ideas scale: twenty years ago I built customizable databases (80K LOC
each), ten years ago I built extensible Java preprocessors (40K LOC each), and more
recently the AHEAD Tool Suite (250K LOC). All used the ideas that programs are


The Objects and Arrows of Computational Design

7

values and transformations (features) map simple programs to more complex programs.3
MM
Now consider the connection of SPLs to
MDE. Fig. 8 shows a metamodel MM and its cone
s iz e o f
s iz e o f

d o m a in is
S P L is
of instances. For typical metamodels, there is an
in fin ite
fin ite
infinite number of instances. An SPL, in contrast, is always a finite family of n similar programs (where n may range from 2 to thousands
or more). So an SPL is a miniscule subset of a
flig h t
metamodel’s domain. In fact, there is an infinite IB M d is k M o to ro la
O tis
h a n d -h e ld
b o o k in g
e le v a to r
ra d io
p o rtle t
number of SPLs in a domain. If MM is a meta- ddorivm aeinr
d o m a in
d o m a in
d o m a in
model of state charts, it would not be difficult to
find SPLs for, say, an IBM disk driver domain, a
Fig. 8. SPLs and Metamodels
portlet flight booking domain, and many others.
As mentioned earlier, SPLs define relationships between its programs. How? By arrows,
P2
of course. Fig. 9 shows the calculator product
sub
format
line with its four programs, along with the
P1

P3
empty program 0, which typically is not a 0
base
member of an SPL. Each arrow is a feature.
sub
format
From the last section, it is not difficult to recP4
ognize that an SPL is itself a trivial category:
each point is a domain with a single program
in it, there are implied identity arrows and im- Fig. 9. Category of the Calculator SPL
plied composed arrows, as required.
Embodied in our description of SPLs is a fundamental approach to software design
and construction, namely incremental development. Programs are built, step-by-step,
by incrementally adding features. Not only does this control program complexity and
improve program understandability, it also allows for the reuse of features (i.e., multiple programs in a product line could share the same feature). More on this shortly.
By composing arrows (features), the programs of an SPL are created. A program’s
design is an expression (i.e., a composition of arrows), and a program can have multiple, equivalent designs. For example, program P3 has two equivalent designs: P3=format•sub•base(0) (which we henceforth abbreviate to P3=format•sub•base) and
P3=sub•format•base. Evaluating both expressions yields exactly the same program.
Features sub and format are said to be commutative because they modify mutually
disjoint parts of a program.
3.1 Pragmatics of Software Product Lines
If there are n optional features, there can be 2n different programs. We see a miniature
example of this in Fig. 9: there are 2 optional features (format and sub) and there are
3

Readers who are familiar with the decorator pattern will see a similarity with features: a decorator wraps an object to add behaviors. Features can be dynamically composed, but in this paper, they are statically composed to produce programs. Another difference is scale: decorators
wrap a single object, whereas features often modify many classes of a program simultaneously.


8

D. Batory, M. Azanza, and J. Saraiva

22=4 programs in the product line. A slightly
larger and more illustrative example is Fig.
10. We want to create an SPL of many programs; we know the arrows that allow us to
build each of these programs, and many pro- 0
grams use the same feature, e.g., the thick
arrows of Fig. 10 denote the application of the
green feature to 4 different programs, and the
dashed arrows denote the application of the
Fig. 10. Reuse of Arrows in SPLs
blue feature to 3 different programs. It is the
reuse of arrows that makes them more economical to store than programs.
As an aside, features are like database transactions:
MM
they make changes to a program that are not necessarily
localized: changes can appear anywhere in a program.
But the key is that either all changes are made, or none
are. Further, features can produce non-conforming programs (non-conforming models). Fig. 11 depicts an
P3 F P6
arrow F that relates programs P3 and P6, both of which
conform to metamodel MM. But by arrow composibility,
F1
F3
we see that F=F3•F2•F1. Applying F1 to P3 yields proP4
P5
gram P4, and applying F2 to P4 yields program P5, and
F2
P6=F3(P5). Note that programs P4 and P5 do not conform

Fig. 11. F=F3•F2•F1
to MM. It is common for existing features to be decomposed into compositions of smaller features, the individual application of which does not preserve conformance properties of the resulting program or model.4 The reason why these smaller arrows arise is that features often have a lot of code in common. Commonalities can be
factored into small features (small arrows) that are shared in implementations of larger
arrows. We will see examples of small arrows in the next section.
3.2 Arrow Implementations
There are two ways in which arrows are implemented. First is to implement arrows in
the ATL, GReAT, etc. languages. The second and standard way for SPLs is that arrows are program or model deltas — a set of changes — that are superimposed on
existing models (e.g., AHEAD [9], Scala [28], Aspectual Feature Modules [5], and
AspectJ [22]). In effect, deltas can be viewed as a specific example of model weaving
[15]. Which approach — writing modules that are to be superimposed or writing
transformations— is “better”? This is not clear; I am unaware of any study to compare their trade-offs. In this paper, I focus solely on the use of deltas, so that core concepts in SPLs can be given their most direct MDE interpretation.
Here is an example. Fig. 12a shows the AHEAD representation of the sub feature
of our calculator SPL. It states that the calculator class is extended with a “void
sub(int x)” method, and the gui class is extended with a new field (JButton sub),
4

Conformance for a program could be whether it type checks or not.