Towards Co-evolution in Model-Driven Development Via Bidirectional

Higher-Order Transformation

Bernhard Hoisl

1,2

, Zhenjiang Hu

and Soichiro Hidaka

Institute for Information Systems and New Media, WU Vienna, Vienna, Austria

Secure Business Austria Research (SBA Research), Vienna, Austria

National Institute of Informatics, Tokyo, Japan

Keywords:

Model-Driven Development, Model Co-evolution, Bidirectional Transformation, Higher-Order Transforma-

tion.

Abstract:

In model-Driven development (MDD), metamodels, models, and model transformations are interdependent.

A change in one artifact must be reﬂected in all other related artifacts. Regardless of their dependencies,

(meta)models and transformations can evolve autonomously rendering referenced artifacts invalid. Coupling

the evolution of models to their corresponding metamodels tries to prevent such mismatches, but is currently

limited to one-way adaptations and does not take model transformations into account. To eliminate these short-

comings, we combine ﬁrst-class transformation models with bidirectional transformations (BX). Our generic

approach integrates BX into well-established Eclipse-based MDD tools, thereby neither being restricted to a

speciﬁc modeling nor model transformation language.

1 INTRODUCTION

In model-driven development (MDD), numerous

models and transformations on different abstraction

levels need to be taken into account. The high

number of models involved originate from a lay-

ered modeling architecture (i.e. metamodels, MMs)

as well as from reﬁnements (i.e. transformations)

from generic to implementation-centric model repre-

sentations (Sendall and Kozaczynski, 2003). On the

one hand, the need for model transformations is inher-

ent to the abstraction mechanism in MDD to represent

platform-speciﬁc concepts (e.g., statements in a pro-

gramming language) as platform-independent models

(Schmidt, 2006). On the other hand, model trans-

formation necessities stem also from, for instance,

changes in MMs (model-to-model transformations,

M2M) or the support for multiple platforms (model-

to-text transformations, M2T).

MDD-based artifacts are frequently subject to

change and evolve over time (Di Ruscio et al., 2012).

In most cases, the evolution of (meta)models and

model transformations is a manual process (Meyers

and Vangheluwe, 2011). Individually maintain and

manually evolve MDD speciﬁcations is a tedious and

error-prone task (Stevens, 2010; Di Ruscio et al.,

2011). For instance, consider an evolution of a MM

and accompanying constraints. First, all instance

models need to be migrated in order to conform to

the new MM deﬁnition. Furthermore, all model trans-

formations need to be adapted (e.g., due to model

type changes). Moreover, tests need to be rewritten to

check that the generated source code fulﬁlls the spec-

iﬁed constraints.

The artifacts which make up a MDD process

(models, M2M/M2T transformations, model and

transformation constraints etc.)—although highly

interdependent—are autonomously maintained.

Changes in one artifact (e.g., in a model) are not

automatically reﬂected in other dependent artifacts

(e.g, in a M2T transformation). The barrier for a

tight integration of MDD-based artifacts stems from

two limitations of current approaches: 1) Model

transformations are unidirectional and changes can

be propagated in one direction only (e.g., a model

change is reﬂected in generated code); 2) changes

can only be propagated into output artifacts of trans-

formations (e.g., models), not into transformation

deﬁnitions themselves.

In order to overcome these co-evolution problems,

our approach, on the one hand, is based on 1) estab-

lishing bidirectional transformations (BX) between

modeling artifacts (Stevens, 2010). BX is a mecha-

nism for maintaining the consistency of two (or more)

466

Hoisl B., Hu Z. and Hidaka S..

Towards Co-evolution in Model-Driven Development Via Bidirectional Higher-Order Transformation.

DOI: 10.5220/0004809004660471

In Proceedings of the 2nd International Conference on Model-Driven Engineering and Software Development (MODELSWARD-2014), pages 466-471

ISBN: 978-989-758-007-9

 2014 SCITEPRESS (Science and Technology Publications, Lda.)

related sources of information. A BX between two

sources of information

and

(e.g., two different

models) comprises a pair of unidirectional transfor-

mations: one from

(forward transformation)

and another from

(backward transformation)

(Czarnecki et al., 2009).

On the other hand, we apply 2) higher-order

transformations (HOTs) on ﬁrst-class model repre-

sentations of transformation speciﬁcations (Tisi et al.,

2009). A HOT “is a model transformation such that

its input and/or output models are themselves trans-

formation models. [. . . ] This demands the represen-

tation of the transformation as a model conforming to

a transformation MM” (Tisi et al., 2009).

In this way, we are able to propagate changes in

two directions (1): From a source model to a target

model and vice versa. These changes can be propa-

gated into models on the same or on different abstrac-

tion levels. Furthermore, we ensure not only the co-

evolution of models, but (2) model transformations,

as well. We represent transformation deﬁnitions as

models and are able to propagate changes into hori-

zontal and vertical model transformations (i.e. trans-

formations between models on the same and on dif-

ferent abstraction levels).

Our contributions are as follows:

• A Method for MDD-based Co-evolution: Our ap-

proach of bidirectional higher-order transforma-

tion (B-HOT) for the co-evolution of model arti-

facts builds on former work (Hidaka et al., 2009;

Hidaka et al., 2011; Sasano et al., 2011; Hoisl

et al., 2013). This paper presents ﬁrst enhance-

ment steps which will allow for coupling, syn-

chronization, and tracing of all model artifacts in-

volved in a MDD process.

• Integrated Tool Support: We provide initial pro-

totypes for an integrated MDD-based tool support

for B-HOTs via the Eclipse IDE. Our implemen-

tations build on well-established MDD tools (e.g.,

Eclipse EMF, ATL, Epsilon)

• Conformance between BX and MDD: To facili-

tate reproduction and transferability, we present

an approach independent of any transformation

language and we prepare for generalizations ac-

cording to OMG speciﬁcations, for example,

MOF, QVT, MOFM2T. Besides integrated BX

and MDD tooling, we also want to contribute to

establish a common terminology to bridge the gap

between the BX and MDD communities (Czar-

necki et al., 2009; Hu et al., 2011).

All software artifacts are publicly available at

http://www.biglab.org and http://nm.wu.ac.at/modsec.

2 CURRENT APPROACHES

A traditional model-driven architecture (MDA), as

proposed by the OMG (B

ezivin and Gerb

e, 2001) and

as supported by a variety of tools, is sketched in Fig-

ure 1. MMs provide the reference frame to which in-

stance models must conform to, for example, a UML

class model conforms to its MM deﬁned in the UML

speciﬁcation. M2M transformations are applied over

one or more input models with the purpose of gener-

ating one or more output models conforming to the

same or different MMs. A typical M2M transforma-

tion example is the generation of platform-speciﬁc

models (PSMs) from platform-independent models

(PIMs). As models are a means for abstraction, they

mostly do not capture enough implementation details

to be directly executable. Hence, M2T transforma-

tions generate textual artifacts (e.g., source code, con-

ﬁguration documents) which can be deployed on a

speciﬁc platform.

Metamodel

Model

transformation

refers to

applies to

generates

Model

instance of

generates

Platform artifact

M2T

M2M

Figure 1: Traditional model-driven architecture.

When a MDD-based artifact evolves, changes

must be reﬂected in all dependent (meta)models,

transformations, and platform artifacts. The com-

plexity of change operations increases with the num-

ber of different modeling languages (MMs, mod-

els), intermediary model representations (M2M trans-

formations), and supported platforms (M2T trans-

formations) involved. Current approaches cannot

sufﬁciently cope with the co-evolution of multiple

MDD-based artifacts because of restrictions to ex-

press and propagate changes which manifest in 1) uni-

directional model transformations and 2) disregarding

transformation deﬁnitions as ﬁrst-class models (see

Figure 1). An example for evolution mismatches is

the inability to reﬂect changes in generated platform

artifacts back to their corresponding instance mod-

els. For example, in Eclipse EMF, changes to the

generated Java source code may be lost when ex-

ecuting the unidirectional M2T transformation once

again. Furthermore, by default, the generation tem-

plates (i.e. JET) cannot be adapted, excluding the pos-

sibility to reﬂect changes in the code generator logic

(i.e. transformation deﬁnitions are not treated as ﬁrst-

class artifacts).

In (Yu et al., 2012), a platform-speciﬁc (i.e. Java-

bound) solution for the co-evolution problem stated

above is provided. In the approach, BX is used to

TowardsCo-evolutioninModel-DrivenDevelopmentViaBidirectionalHigher-OrderTransformation

467

synchronize models with generated and user-modiﬁed

code. Prerequisites are that the platform-speciﬁc

language encodes a textual duplicate of the PIM

(i.e.

@model

annotations) and that a MM representa-

tion exists for the platform-speciﬁc language (i.e. a

Java Ecore MM).

To establish BX, triple graph grammars (Giese

and Wagner, 2009) are commonly employed in MDD

for keeping related models consistent. Triple graph

transformations relate a source and a target graph

(i.e. a model) by some correspondence graph. In this

way, source and target graphs are coupled which pro-

vides a basic structure for their co-evolution.

In (Wachsmuth, 2007), MM/model co-evolution

is considered as a step-wise adaptation of MMs (via

transformation relations) and instance-preservation of

models. Instead of describing the co-evolution of

models as a transformation between two MMs, (Wim-

mer et al., 2010) employs in-place transformations. In

(Herrmannsdoerfer et al., 2009), a framework is pre-

sented to model the co-evolution of MMs/models via

the composition of coupled transactions to adapt the

MM and specify the corresponding model migrations.

Furthermore, state-based MM/model co-evolution

approaches, for instance, adopt HOTs which take a

difference model obtained by comparing two MMs

and generate a model transformation able to produce

the co-evolution of involved models (Di Ruscio et al.,

2011).

Although all of these co-evolution methods cope

with model transformation restrictions, a combined

and uniform solution is missing, so far. Either the

approaches provide only one-way co-evolution pos-

sibilities (i.e. unidirectional) or only for a subset of

MDD artifacts (e.g., only MM/model co-evolution).

Therefore, in the next section, we propose a generic

approach for co-evolving MDD-related artifacts.

3 MODEL CO-EVOLUTION VIA

B-HOT

With our approach (Figure 2 provides an overview)

we want to overcome shortcomings of current meth-

ods and offer a generic solution for co-evolving MDD

artifacts. The upper part of Figure 2 reﬂects a tradi-

tional MDA. Model co-evolution is achieved by inte-

grating 1) BX capabilities (lower part of Figure 2) and

2) support for HOT into the MDA.

As an example, consider a model transformation

from an object-oriented representation (e.g., a class

diagram) to a relational database model. For instance,

both MMs are deﬁned in a MOF-based language (see

upper part of Figure 2). Hence, their instance models

(e.g., using Ecore as technological projection) con-

form to the EMOF MM. A transformation (e.g., spec-

iﬁed via ATL or ETL) is applied to class models and

generates database models. This forward transforma-

tion proves useful in one case only: Changes in evolv-

ing class models should be reﬂected in database mod-

els, as well. Updates in database models cannot be

propagated back to their source class models. A cou-

pling of both representations limits the target model

to be read-only (otherwise changes get lost when re-

executing the transformation).

In our approach, we integrate BX capabilities by

reusing native MDD concepts. Every transformation

is represented as a ﬁrst-class model conforming to a

transformation MM. B-HOTs (see Figure 2) provide

for the mapping of unidirectional MDD-based trans-

formation models (e.g. deﬁned via ATL or ETL) into

a bidirectional graph transformation model (and vice

versa). Reconsidering the BX of the class-to-database

model transformation example, in a next step, both

source and target models are mapped to a graph struc-

ture (deﬁned via UnCAL, a graph algebra). Source

and target graph schemas are represented as MOF-

based MMs. The BX provides both, a forward trans-

formation from class to database graphs as well as

a corresponding backward transformation (both de-

ﬁned via UnQL

, a SQL-like graph query/transforma-

tion language). Thus, changes in the database graph

can be propagated back to the class graph. As the

transformation of models to graphs is also bidirec-

tional, updated class and database graphs can be rep-

resented in their initial model-based forms. There-

fore, a BX of source and target models (class and

database models in our example) is established. The

backward database-to-class transformation is distinct

to the BX and no corresponding MDD-based transfor-

mation equivalent exists. Therefore, as a last step, the

backward transformation (in UnQL

) can be repre-

sented in its original MDD-based form (in ATL, ETL)

via a B-HOT mapping (see Figure 2).

We discuss co-evolution properties of our ap-

proach according to the following four categories.

Model Relations: Our approach establishes BX-

based relations between models, graphs, and model

and graph representations. The mapping relation

between traditional MDD-based transformations and

BX representations (B-HOT) allows to add BX sup-

port in traditional MDAs. Furthermore, relations are

not restricted to one source and one target artifact

only, but can be used for the transformation of multi-

ple dependent models/graphs, as well (see also com-

positional BX down below). The coupling of models

via BX allows, on the one hand, to establish synchro-

nization deﬁnitions and, on the other hand, to collect

MODELSWARD2014-InternationalConferenceonModel-DrivenEngineeringandSoftwareDevelopment

468

Source representation

Transformation deﬁnition

Target representation

applies to /

generates

generates /

applies to

ETL

Transformation model

instance (M1)

BPMN

UML

Model instance

(M1, source)

instance of

ATL

Ecore

MOFM2T

QVT

Metamodel

(M2, source)

(E)MOF

instance of /

refers to

Meta-metamodel

(M3)

MOF

BPMN

UML

Model instance

(M1, target)

instance of

Ecore

MOFM2T

QVT

Metamodel

(M2, target)

(E)MOF

instance of /

refers to

UnCAL

BX model

instance (M1, HOT)

UnQL

applies to /

generate

UnCAL

BX model

instance (M1)

UnQL

generate /

applies to

Transformation

metamodel (M2)

QVT

instance of

Graph instance

(M1, source)

applies to /

generates

generates /

applies to

Graph instance

(M1, target)

UnCAL

instance of

KM3

Metamodel

(M2, source schema)

EMOF

instance of

KM3

Metamodel

(M2, target schema)

EMOF

UnCAL

BX model

instance (M1)

UnQL

applies to /

generate

generate /

applies to

UnCAL

BX model

instance (M1)

UnQL

applies to /

generate

generate /

applies to

Model-driven development

Bidirectional graph transformation

Model co-evolution

instance of / refers to

UnCAL

instance of

instance of instance of

Figure 2: Overview of our model co-evolution approach.

transformation traces. As many modeling artifacts

make up a MDD process, keeping models consistent

is of special importance. Moreover, trace information

are a relevant source for documentation and debug-

ging purposes.

Model Co-evolution Scenarios: Our approach

supports any M2M relation and any number of MM-

layers. Horizontal co-evolution examples are, for

instance, the synchronization of different MMs or

different instance models. Vertical co-evolution ex-

amples are, for instance, keeping PIMs and PSMs

or instance models and corresponding MMs consis-

tent. Transformation models permit to propagate

changes also in horizontal and vertical M2M and M2T

transformation deﬁnitions, for instance, for the co-

evolution of MMs and transformation models or dif-

ferent transformation models.

Language-independent Integration: Our approach

is not dependent on a speciﬁc model transformation

language, i.e. it does not matter if the model trans-

formation is deﬁned via ATL, ETL, or any other lan-

guage. This is because we do not integrate bidi-

rectionality into a model transformation language di-

rectly. The B-HOT deﬁnition serves as a language-

speciﬁc binding between the concepts of the unidi-

rectional MDD-based transformation and the bidirec-

tional graph transformation. These bindings must be

speciﬁed only once for each MDD-based transforma-

tion language (e.g., ATL, ETL) and facilitate reuse of

our approach.

BX Properties: We develop B-HOTs via a func-

tional bidirectional graph transformation language

(Hidaka et al., 2011). The BX ensures the well-

behavedness of forward and backward transforma-

tions (i.e. that they are consistent with each other)

and satisfy the round-trip property (Czarnecki et al.,

2009). As the BX does not restrict forward trans-

formations to be information preserving, a backward

transformation requires not only the modiﬁed tar-

get graph/model, but also the original source graph/-

model. Large BX can be developed in a composi-

tional way of reusing existing information (e.g., via

intermediate models). Compositional BX can be em-

ployed, on the one hand, for a pair of consecutive

transformations, where the output of transformation

is the input of transformation

; for example, the

output of the source model-to-graph transformation is

fed into the forward source-to-target graph transfor-

mation (see Figure 2). On the other hand, compo-

sitional BX can be used for a pair of transformations

that share an identical input model, for instance, trans-

formations from one PIM to multiple PSMs (Hidaka

et al., 2009).

4 B-HOT REQUIREMENTS

This paper provides a ﬁrst step to make co-evolution

in MDD via B-HOTs possible. Initial work regarding

the methodology and accompanying tool support has

TowardsCo-evolutioninModel-DrivenDevelopmentViaBidirectionalHigher-OrderTransformation

469

been performed, but is far from being ﬁnalized. In

this section, we list challenging requirements for the

implementation of our approach. We present com-

pleted work and discuss prerequisites for future de-

velopments.

Transformation MMs: Our B-HOT approach re-

lies on transformation (meta)models. MDD-based

M2M transformation MMs exist, for instance, for

ATL (Tisi et al., 2009) and for a subset of the

Epsilon-language family (Wei, 2012). Regarding

M2T transformations, (Hoisl et al., 2013) extended

the Epsilon model representations of (Wei, 2012).

The BX framework (Hidaka et al., 2011) does not

need MM representations for the UnQL

and UnCAL

languages. Syntax deﬁnitions in BNF exist for

both languages and need to be mapped to EMOF-

compliant (i.e. Ecore-based) MM representations (on-

going work; see also Section 5).

MM-speciﬁc Bindings: For a B-HOT, language-

speciﬁc bindings need to be established between uni-

and bidirectional transformation MMs. Initial work

provides an unidirectional transformation from ATL

to UnQL

, whereby the transformation does not take

the model representation of ATL into account (Sasano

et al., 2011)

. Thus, language-speciﬁc bindings

for, for instance, ATL and/or ETL to UnQL

and/or

UnCAL via B-HOT is future work. Furthermore, a

ﬁrst prototype exists for the BX of model-to-graph

representations (Ecore-based models to UnCAL and

vice versa), but needs improvements (future work).

Round-tripping of transformation deﬁnitions: Our

B-HOT approach demands transformation models as

input. In contrast, most model transformation engines

cannot execute model representations of transforma-

tion deﬁnitions. Therefore, the round-tripping of exe-

cutable (i.e. text-based) transformation speciﬁcations

and their model representations must be provided. For

M2M transformations, “an ATL transformation is it-

self a model, conforming to the ATL MM” (Tisi et al.,

2009). Furthermore, (Wei, 2012) developed initial

round-tripping support for an Epsilon subset which

was extended for M2T transformations (i.e. EGL) by

(Hoisl et al., 2013). Currently, the automatically de-

rived backward transformation of a BX can neither

be expressed as UnQL

or UnCAL textual statements

nor via corresponding model representations (future

work).

Generic Mappings: Prototype developments de-

This separate work of integrating ATL and BX is per-

formed in collaboration with the AtlanMod team, uses the

same BX framework (GRoundTram), but in contrast focuses

on unidirectional transformations from ATL to UnQL

with

a concrete semantic alignment between these two technical

spaces.

ﬁne transformations in a speciﬁc language as imple-

mentation vehicle (e.g, ATL, ETL). To support up-

take and transferability of our approach we need to

establish mappings to OMG speciﬁcations (see also

Figure 2). (Hoisl et al., 2013) provides mappings be-

tween EGL-based M2T transformation concepts used

for the prototype and the MOFM2T speciﬁcation. As

future work, uni-/bidirectional M2M transformation

concepts (e.g., ATL, ETL, UnQL

) will be mapped to

the QVT speciﬁcation.

Development Support: Initial support for the

requirements-driven testing of (meta)models and

model transformations via scenarios is provided by

(Sobernig et al., 2013). Furthermore, validation for

source and target models as well as for BX is pre-

sented in (Hidaka et al., 2011). As future work we

will implement an IDE (e.g., a text editor) to support

the development of UnQL

BX and UnCAL-based

graphs. For this task, Eclipse Xtext is a candidate

framework as it combines the grammar speciﬁcation

for a textual syntax with an Ecore-based model repre-

sentation and provides for an Eclipse-based IDE.

Combine BX and MDD: Model (i.e. graph) trans-

formations are important to both BX and MDD (Czar-

necki et al., 2009; Hu et al., 2011). Our approach

allows to integrate BX into MDD, thereby reusing

native methods and tools for both. We want to

support the creation of a shared terminology (Czar-

necki et al., 2009) via the generalization and mapping

of language-speciﬁc uni-/bidirectional transformation

concepts to OMG speciﬁcations. After our develop-

ments have matured, as future work, we need to pro-

vide for a larger case study to show that our approach

works in practice.

5 CONCLUDING REMARKS

In this paper, we presented an approach for model

co-evolution by combining BX and HOT for MDD.

The developed method (B-HOT) intends to overcome

current limitations for model co-evolution as transfor-

mations are represented as models and model trans-

formations are bidirectionalized. In our approach,

models are coupled via BX providing the beneﬁt

that synchronization of models is ensured via for-

ward/backward transformations. Another advantage

is that changes can be propagated into model trans-

formations keeping them consistent with their evolv-

ing dependent artifacts (MMs, model instances). Our

approach of integrating BX into MDD is generic and

can be applied to any model transformation language

via binding speciﬁcations.

A drawback of our proposal is that the efforts of

MODELSWARD2014-InternationalConferenceonModel-DrivenEngineeringandSoftwareDevelopment

470

creating initial modeling and transformation artifacts

can be high. Transformation MMs may have to be

deﬁned for the intended target language. Currently,

no bindings for transformation languages exist. Al-

though these have to be deﬁned only once for each

language, this is a barrier for uptake. Transformation

engines might not execute models directly making

text/model round-tripping functions necessary (but

again these can be reused per language). Adequate

tool support must be provided to facilitate the devel-

opment of models and transformations.

Currently, we are developing an EMOF-based

MM for the UnQL

BX language (in Ecore). In par-

allel, we transfer the BNF-based grammar deﬁnition

to Xtext. This will ensure the consistent mapping of

transformations written in UnQL

to their modeling

equivalents. An editor to support the deﬁnition of

UnQL

statements will be provided, as well. Initial

developments are available at the URLs mentioned

in the footnote of Section 1 and are continuously up-

dated. UnQL

concepts will be mapped to the QVT

relations language in the near future.

ACKNOWLEDGEMENTS

This work has partly been funded by t he Austrian Re-

search Promotion Agency (FFG) of the Austrian Fed-

eral Ministry for Transport, Innovation and Technol-

ogy (BMVIT) through the Competence Centers for

Excellent Technologies (COMET K1) initiative and

the FIT-IT program.

REFERENCES

ezivin, J. and Gerb

e, O. (2001). Towards a precise deﬁni-

tion of the OMG/MDA framework. In Proc. 16th Int.

Conf. Automated Softw. Eng., pages 273–280. IEEE.

Czarnecki, K., Foster, J. N., Hu, Z., L

ammel, R., Sch

urr,

A., and Terwilliger, J. F. (2009). Bidirectional trans-

formations: A cross-discipline perspective. In Theory

and Practice of Model Transformations, volume 5563

of LNCS, pages 260–283. Springer.

Di Ruscio, D., Iovino, L., and Pierantonio, A. (2011). What

is needed for managing co-evolution in MDE? In

Proc. 2nd Int. Workshop Model Comparison in Prac-

tice, pages 30–38. ACM.

Di Ruscio, D., Iovino, L., and Pierantonio, A. (2012). Cou-

pled evolution in model-driven engineering. IEEE

Softw., 29(6):78–84.

Giese, H. and Wagner, R. (2009). From model transforma-

tion to incremental bidirectional model synchroniza-

tion. SoSyM, 8(1):21–43.

Herrmannsdoerfer, M., Benz, S., and Juergens, E. (2009).

COPE – automating coupled evolution of metamodels

and models. In Proc. 23rd European Conf. Object-

Oriented Programming, pages 52–76. Springer.

Hidaka, S., Hu, Z., Inaba, K., Kato, H., and Nakano, K.

(2011). GRoundTram: An integrated framework for

developing well-behaved bidirectional model trans-

formations. In Proc. 26th Int. Conf. on Automated

Softw. Eng., pages 480–483. IEEE.

Hidaka, S., Hu, Z., Kato, H., and Nakano, K. (2009). To-

wards a compositional approach to model transforma-

tion for software development. In Proc. 24th Sympo-

sium on Applied Computing, pages 468–475. ACM.

Hoisl, B., Sobernig, S., and Strembeck, M. (2013). Higher-

order rewriting of model-to-text templates for inte-

grating domain-speciﬁc modeling languages. In Proc.

1st Int. Conf. Model-Driven Eng. and Softw. Develop-

ment, pages 49–61. SciTePress.

Hu, Z., Schurr, A., Stevens, P., and Terwilliger, J. F.

(2011). Dagstuhl seminar on bidirectional transfor-

mations (BX). SIGMOD Rec., 40(1):35–39.

Meyers, B. and Vangheluwe, H. (2011). A framework for

evolution of modelling languages. Sci. Comput. Pro-

gram., 76(12):1223–1246.

Sasano, I., Hu, Z., Hidaka, S., Inaba, K., Kato, H., and

Nakano, K. (2011). Toward bidirectionalization of

ATL with GRoundTram. In Proc. 4th Int. Conf. The-

ory and Practice of Model Transformations, pages

138–151. Springer.

Schmidt, D. C. (2006). Guest editor’s introduction: Model-

driven engineering. Computer, 39(2):25–31.

Sendall, S. and Kozaczynski, W. (2003). Model transfor-

mation: The heart and soul of model-driven software

development. IEEE Softw., 20(5):42–45.

Sobernig, S., Hoisl, B., and Strembeck, M. (2013).

Requirements-driven testing of domain-speciﬁc core

language models using scenarios. In Proc. 13th Int.

Conf. Quality Softw., pages 163–172. IEEE.

Stevens, P. (2010). Bidirectional model transformations in

QVT: Semantic issues and open questions. SoSyM,

9(1):7–20.

Tisi, M., Jouault, F., Fraternali, P., Ceri, S., and B

ezivin,

J. (2009). On the use of higher-order model transfor-

mations. In Model Driven Architecture – Foundations

and Applications, volume 5562 of LNCS, pages 18–

33. Springer.

Wachsmuth, G. (2007). Metamodel adaptation and model

co-adaptation. In Proc. 21st European Conf. Object-

Oriented Programming, pages 600–624. Springer.

Wei, W. (2012). EpsilonLabs: Epsilon static analy-

sis. Available at:

http://code.google.com/p/

epsilonlabs/wiki/EpsilonStaticAnalysis

Wimmer, M., Kusel, A., Sch

onb

ock, J., Retschitzegger, W.,

Schwinger, W., and Kappel, G. (2010). On using in-

place transformations for model co-evolution. In Proc.

2nd Int. Workshop Model Transformation with ATL.

INRIA & Ecole des Mines de Nantes.

Yu, Y., Lin, Y., Hu, Z., Hidaka, S., Kato, H., and Montrieux,

L. (2012). Maintaining invariant traceability through

bidirectional transformations. In Proc. 34th Int. Conf.

Softw. Eng., pages 540–550. IEEE.

TowardsCo-evolutioninModel-DrivenDevelopmentViaBidirectionalHigher-OrderTransformation

471