Change-Driven Model Transformations
Derivation and Processing of Change Histories
Istva´n Ra´th1, Gergely Varro´2, and Da´niel Varro´1
1 Budapest University of Technology and Economics,
Department of Measurement and Information Systems,
{rath, varro}@mit.bme.hu
2 Department of Computer Science and Information Theory,
H-1117 Magyar tudo´sok krt. 2, Budapest, Hungary
gervarro@cs.bme.hu
Abstract. Nowadays, evolving models are prime artefacts of model-driven soft-
ware engineering. In tool integration scenarios, a multitude of tools and modeling
languages are used where complex model transformations need to incrementally
synchronize various models resided within different external tools. In the paper,
we investigate a novel class of transformations, which is directly triggered by
model changes. First, model changes in the source model are recorded incremen-
tally by a change history model. Then a model-to-model transformation is carried
out to generate a change model for the target language. Finally, the target change
history model is processed (at any time) to incrementally update the target model
itself. Moreover, our technique also allows incremental updates in an external
model where only the model manipulation interface is under our control (but not
the model itself). Our approach is implemented within the VIATRA2 framework,
and it builds on live transformations and incremental pattern matching.
Keywords: incremental model transformation, change models, change-driven
transformations
1 Introduction
Model transformations play a key role in model-driven software engineering by provid-
ing embedded design intelligence for automated code generation, model refactoring,
model analysis or reverse engineering purposes.
Most traditional model transformation frameworks support batch transformations
where the execution of a transformation is initiated (on-demand) by a systems designer.
Most traditional model transformation frameworks follow this approach. As an alternate
solution (proposed recently in [1, 2]), live transformations (or active transformations)
run in the background as daemons, and continuously react to changes in the underlying
models. In this respect, a transformation can be executed automatically as soon as a
transaction on the model has completed.
Up to now, the design and execution of batch transformations and live transfor-
mations were completely separated, i.e. the same transformation problem had to be
formulated in a completely different way.

In the current paper, we try to bridge this conceptual gap by introducing change-
driven model transformations. More specifically, we first define the concept of a change
history model, which serves as a history-aware log of elementary model changes, which
record causal dependency / timeliness between such changes. We show how change his-
tory models can be derived incrementally by live transformations during model editing.
Then we describe how change history models can be used to incrementally update a
model asynchronously (i.e. at any desired time) by propagating changes using batch
transformations.
The use of change history models in model-to-model transformation scenarios has
far-reaching consequences as incremental model transformations can be constructed
with minimal knowledge about the current structure of the target model. For instance,
transformations can still be implemented when only identifiers and a model manipu-
lation interface are known, but the rest of the actual target model is non-materialized
(i.e. does not exist as an in-memory model within the transformation framework). As
a result, our concepts can be easily applied in the context of runtime models as well
as incremental model-to-code transformation problems (where the latter will actually
serve as the running example of the paper).
The rest of the paper is structured as follows. In Sec. 2, a motivating case study is
introduced as a running example for our paper. The main concepts of change-driven
transformations and change history models are introduced in Sec. 3. Section 4 details
the main steps of the approach on the running example. Finally, Section 5 summarizes
related work and Sec. 6 concludes our paper.
2 Motivating scenario
Our motivating scenario is based on an actual tool integration environment developed
for the SENSORIA and MOGENTES EU research projects.Here high-level workflow
models (with control and data flow links, artefact management and role-based access
control) are used to define complex development processes which are executed auto-
matically by the JBoss jBPM workflow engine, in a distributed environment consisting
of Eclipse client workstations and Rational Jazz tool servers. The process workflows
are designed in a domain-specific language, which is automatically mapped to an an-
notated version of the jPDL execution language of the workflow engine. jPDL is an
XML-based language, which is converted to an XML-DOM representation once the
process has been deployed to the workflow engine.
A major design goal was to allow the process designer to edit the process model and
make changes without the need for re-deployment. To achieve this, we implemented an
asynchronous incremental code synchronizing model transformation. This means that
(i) while the user is editing the source process model, the changes made are recorded.
Then (ii) these changes can be mapped incrementally to the target jPDL XML model
without re-generating it from scratch. Additionally, (iii) the changes can be applied
directly on the deployed XML-DOM representation through jBPM’s process manipu-
lation DOM programming interface, but, (iv) in order to allow the changes to applied
to the remote workflow server, the actual XML-DOM manipulation is executed on a
remote host asynchronously to the operations of the process designer.