Toward bidirectionalization of ATL with GRoundTram
Isao Sasano1 , Zhenjiang Hu2 , Soichiro Hidaka2 , Kazuhiro Inaba2 , Hiroyuki Kato2 ,and Keisuke Nakano3
1

Shibaura Institute of Technology, Japan,
sasano@sic.shibaura-it.ac.jp
2
National Institute of Informatics, Japan,{hu, hidaka, kinaba, kato}@nii.ac.jp
3
The University of Electro-Communications, Japan,
ksk@cs.uec.ac.jp

Abstract. ATL is a language for describing model transformations currently
in uni-direction. In our previous work we have shown that transformations ofgraph structures given in some form can be bidirectionalized and have implemented a system called GRoundTram system for bidirectional graph transformations. We say a transformation t is bidirectionalized when we obtain a backward
transformation t′ so that the pair (t, t′ ) of transformations satisfies certain wellbehavedness properties. Bidirectional model transformation is used to reflect thechanges in the target model back to the source model, and vice versa. In thispaper, as a first step toward realizing practical bidirectional model transformations, we present bidirectionalization of core part of the ATL by encoding it in
the UnQL language, which is used as a transformation language in the GRoundTram system. We give the algorithm for the encoding, based on which we have
implemented the system for bidirectionalizing the core ATL in OCaml language.

1

Introduction

ATL [15, 14, 1] is a widely used language for describing model transformation, andits environment is provided as an easy-to-use plug-in of the Eclipse framework. An
ATL program consists of rules which specify how to transform components of a source
model into components of a target model. A rule can describe computations like integer
arithmetic or string manipulations and check various conditions in OCL expressions,and can change the structure between components when producing the target model.
This rule-based mechanism enables us to declaratively describe a wide variety of modeltransformations.
Despite its practical and wide uses, ATL lacks the important bidirectional featurein that it can only describe unidirectional mapping from the source model to the target
model. Bidirectionality, as being seen in many other model transformation languages
such as QVT and TGG [17], plays an important role in model synchronization, consistency maintenance, and reverse engineering [9]. One attempt to bidirectionalize ATL
was made in the level of byte code of the virtual machine of ATL system [20], but it
imposes many restrictions on the ATL byte code, and this restrictions on the lower byte
code is somehow difficult to be understood and controlled by the users who write ATL
programs.

2

Isao Sasano et al.

As an alternative, by contrast to the low level attempt, we shall take an incremental
approach to bidirectionalizing ATL in a high level. Our idea is to show that a small coreof ATL can be bidirectionalized, while making use of the fact that this core part cancoexist well with other parts that cannot be bidirectionalized. This coexistence is possible because of modular execution of ATL programs; each rule specifies direct mappingfrom some elements in the input model to those in the output model. This core part could
be extended and generalized in the future to deal with more of bidirectional computation in an ATL program. Now the problem is how to bidirectionalize ATL transformation rule, the basic unit of model transformation. Can we use the existing bidirectional
languages to interpret ATL?
Bidirectional transformations, originated from the view update problem in the
databases [4], have received much attention from the programming language community, and several well-behaved bidirectional transformation languages have been
proposed [7, 16, 13, 18, 5, 19], where the round-trip properties like put-get or get-put,
which characterizes the bidirectional transformations, are guaranteed to be satisfied.
However, most of these well-behaved bidirectional transformation languages manipulate trees or strings, which are not suitable for bidirectionalizing ATL, because models
are essentially graphs. Recently, in our previous work [11] it is shown that the UnQL
language [8], a well-known graph query language, can be used as a well-behaved
bidirectional graph transformation language. In addition, a bidirectional graph transformation system called GRoundTram (Graph Roundtrip Transformation) [2] has beendeveloped, where we can write bidirectional graph transformations in the UnQL language.
In this paper, as a first step toward realizing practical and well-behaved bidirectional model transformations, we present bidirectionalization of core part of the ATL
by encoding it in the UnQL language. We give the algorithm for the encoding, based on
which we have implemented the system for bidirectionalizing the core ATL in OCaml
language. With representing the source model in a graph data structure, we can bidirectionally apply the encoded transformation in GRoundTram system. Throughout the
paper we use a simple example to illustrate our algorithm.
The organization of this paper is as follows. Section 2 shows the overview of ATL,
GRoundTram system, and UnQL language. Section 3 shows the encoding and decoding
process between models and UnQL graph structures. Section 4 presents the algorithm
for encoding ATL rules. Section 5 concludes the paper.

2

Preliminaries

Here we show the overview of the ATL, UnQL, and the GRoundTram system.
2.1

ATL

In this paper we use the following subset of the ATL language to show the essential
part of the bidirectionalization. The subset does not cover imperative features of the
ATL. We also exclude the most of the OCL expressions to avoid cluttering the essential
part of the bidirectionalization. Although the subset may not have the same description

Toward bidirectionalization of ATL with GRoundTram

3

power as the full set, it is enough for the purpose of showing the idea of our approachto bidirectionalization of model transformations.
AT L = module id; create id : id; from id : id; rule+
rule = rule id from inPat to outPat +inPat = id : oclType
outPat = id : oclType binding ∗binding = id ← oclExp
oclExp = id
| id.id| string| oclExp + oclExp
ATL consists of rules, each of which specifies a transformation that is applied tosome components in the source model. A rule is described by the rule construct in
the above syntax and the inPat construct id: oclType in each rule specifies to which
component the rule is applied. For the details of ATL, refer to the documents in the ATL
web page [1].
Here we illustrate the intuitive meaning of the ATL language by using an example inFig. 1. It consists of two rules, Class2Table and Attribute2Column. The example ismade by simplifying the class2RDBMS example provided as a non-trivial benchmark
application for testing the power of model transformation languages in the announcement of the workshop MTiP 2005 [6].
In ATL we need to specify the metamodels for source models and target models.
Let the metamodel of source models be the one in Fig. 2 and the metamodel of target
models be the one in Fig. 3. In the ATL environment the metamodels are described by
the ECore diagram or KM3 (kernel meta meta model) [3]. The metamodels in Fig. 2
and 3 are given in KM3.
Let us use the model in Fig. 4 as an example of the source model. This model specifies that a Person class has two attributes (fields), name and address. This is transformed
into the target model in Fig. 5. In the next section we give the core idea of bidirectionalizing ATL by using the example given above.
2.2

UnQL

Let us briefly review the graph querying language, UnQL [8]. The language resembles
the SQL for relational databases in its select-where syntax, but is designed for manipulating graphs. In particular, it has a construct called structural recursion to traverse
over the given input graphs. We omit the formal definition of the language, which canbe found in [8]. We here informally present the basic concepts of UnQL starting with
its graph data model.
Graph Data Model Graphs in UnQL are rooted and directed cyclic graphs with noorder between outgoing edges. They are edge-labeled in the sense that all informationis stored as labels on edges and the labels on nodes serve as a unique identifier andhave no particular meaning. The edge-labels can be either integers (e.g., 123, or 42),4Isao Sasano et al.

rule Class2Table {froms : ClassDiagram!Classtot : Relational!Table (name <- s.name,col <- s.attr)}
rule Attribute2Column {froms : ClassDiagram!Attributetot : Relational!Column (name <- s.name)}Fig. 1. A model transformation in ATL

strings (like "hello") for representing data-values, or bare-symbols (name, or attr)
for representing structures of graphs.
Two graphs in UnQL are considered to be equal if they are bisimilar. Intuitive understanding of bisimulation is that unfolding of cycles and duplication of equivalentsubgraphs are not distinguished, and unreachable part from the root is ignored. Here isan examples of graphs that are bisimilar:◦ •/ ]
a

b

b b b
a/ b/
a {=• /• /• /•]
◦
•
•
]
{
≡
≡ ◦ a /• b /•]
.
b
b

b

Every construct in UnQL respects bisimulation, i.e., if two bisimilar graphs are fed as
inputs to a query, the results are always bisimilar again. This notion of equivalence plays
an important role for query optimization [8] or bidirectionalization [11]. When the user
does want to distinguish two bisimilar graphs as a different object, the user can add
special tag edges labeled with unique identifiers to them, which breaks the bisimilarity
and are dealt with separately.
Query Syntax The syntax of UnQL query is summarized in Figure 6. The select T
where B, . . . , B form is the entry point of the query. It selects the subgraphs satisfying
the where B part and bind them to variables, and construct a result according to thetemplate expression T . In T , the expression {L1 : T1 , . . . , Ln : Tn } creates a newnode having n outgoing edges labeled Li and pointing to another node Ti . The unionToward bidirectionalization of ATL with GRoundTram

5

package Class {abstract class NamedElt {attribute name : String;}class Class extends NamedElt {reference attr[*] : Attribute oppositeOf owner;}class Attribute extends NamedElt {reference type : Class;reference owner : Class oppositeOf attr;}}
package PrimitiveTypes {datatype Boolean;
datatype Integer;
datatype String;}

Fig. 2. The meta model in KM3 for the source models

G1 ∪ G2 constructs a graph with a root sharing the roots of G1 and G2 . For example,{L1 : g1 } ∪ {L2 : g2 } equals to {L1 : g1 , L2 : g2 }. In the template, by using the
keyword sfun, the programmer can also define a powerful structural recursion, which
will be explained later. In the binding condition B part, comparison of label values andregular-expression based traversal on paths on graphs can be used.

Structural Recursion A function f on graphs is called a structural recursion if it isdefined by the following equations
f ({})= {}f ({$l : $g}) = ef ($g1 ∪ $g2 ) = f ($g1 ) ∪ f ($g2 ),where the expression e may contain references to variables $l and $g, and recursive
calls of the form f ($g), but no application of f to other graphs than $g. Since the first
and the third equations are common in all structural recursions, we omit them in UnQL.
For the second line, since it is customary to dispatch the graph operation by labels,
pattern-matching can be used instead of using long if-then-else sequence. For instance,

6

Isao Sasano et al.

package Relational {abstract class Named {attribute name : String;}class Table extends Named {reference col[*] : Column oppositeOf owner;}class Column extends Named {reference owner : Table oppositeOf col;}}package PrimitiveTypes {datatype Boolean;
datatype Integer;
datatype String;}

Fig. 3. The meta model in KM3 for the target models

Class

attr

name=”Person”

Attribute
name=”name”

owner
owner

type

attr

Attribute

type

name=”address”

Class
name=”String”

Fig. 4. A source model

we can write
sfun f ({class : $g})
= e1
| f ({interface : $g}) = e2
| f ({int : $g})
= e3
..
.

Toward bidirectionalization of ATL with GRoundTram
Table

col

name=”Person”

Columnname=”name”

owner
owner

col

Columnname=”address”

Fig. 5. The target model obtained by applying the rules to the source modelQT::= select T where B, . . . , B::= Q | {L : T, . . . , L : T } | T ∪ T | $G | f ($G)
| if BC then T else T| let sfun f {Lp : Gp} = T| f {Lp : Gp} = T...
sfun f ′ {Lp : Gp} = T| f ′ {Lp : Gp} = T
...
...
in T
(binding)
B ::= Gp in $G | BC
(condition)
BC ::= not BC | BC and BC | BC or BC| isEmpty($G) | L = L | L ̸= L | L < L | L ≤ L(label)
L ::= $l | a(label pattern)
Lp ::= $l | Rp
(graph pattern)
Gp ::= $G | {Lp : Gp, . . . , Lp : Gp}(regular path pattern) Rp ::= a || Rp.Rp | (Rp|Rp) | Rp? | Rp∗(query)(template)Fig. 6. Syntax of UnQL

instead of writing
sfun f ({$l : $g}) = if $l = class then e1
else if $l = interface then e2
else if $l = int then e3
else . . .
The following example shows a simple usage of structural recursion.
sfun a2d xc({a : $g}) = {d : a2d xc($g)}| a2d xc({c : $g}) = a2d xc($g)| a2d xc({$l : $g}) = {$l : a2d xc($g)}

78Isao Sasano et al.

It replaces all edges in the graph labeled a by d, contracts the edges labeled c, and keeps
the other edges unchanged.
Despite its simplicity, structural recursion (and hence UnQL) is powerful enough todescribe interesting nontrivial model transformations [12].
In this paper, for simplicity, we often write
sfun f ({a : {b : $v}}) = . . .
to denotesfun f ′ ({a : $g}) = let sfun h ({b : $v}) = . . . in h($g).
Bidirectional Semantics Usually, a query is run in one direction. That is, given an
input environment (a mapping from variables to graphs) ρ, a query Q is evaluated andρρ
generated the result graph which we denote F[[Q]] . Now, let G = F[[Q]] and consider′
the user has edited the result graph into G . For example, he can add a new subgraph,or modify some label, or delete several edges, and so on. In our previous work [11], wehave given a backward semantics that properly reflects back the editing to the original
inputs. More formally speaking, given the modified result graph G′ and the original
ρ
input environments ρ, the modified environment ρ′ = B[[Q]]G′ can be computed.
By ”properly reflecting back”, we mean the following two properties to hold.
ρρF[[Q]] = G implies B[[Q]]G = ρρρ
B[[Q]]G′ = ρ′ implies B[[Q]]F [[Q]]ρ′ = ρ′

(G ET P UT )(WP UT G ET )The (G ET P UT ) property says that if no change is made on the output G, then there
should occur no change on the input environment. The (WP UT G ET ) property is anunrestricted version of (P UT G ET ) property appeared in [10], which requires G′ ∈ρρ′Range(F[[Q]]) and B[[Q]]G′ = ρ′ to imply F[[Q]] = G′ . The (P UT G ET ) property
states that if a result graph is modified to G′ which is in the range of the forward evaluation, then this modification can be reflected to the source such that a forward evaluation
will produce the same result G′ . In contrast to it, the (WP UT G ET ) property allows themodified result and the result obtained by backward evaluation followed by forward
evaluation to differ, but require both to have the same effect on the original source if
backward evaluation is applied.
2.3

GRoundTram system

In our previous work we have developed a system called GRoundTram system, whichenables us to describe bidirectional transformations on graph data structures in the
UnQL language. Note that we describe both the transformations and the graph data
structures in UnQL language. We show the overview of the system in Fig. 7. Our system implements the bidirectional evaluator between source graphs and target graphs.
Figure 8 shows a screenshot of our system. The user loads a source graph (displayedin the left pane) and a transformation written in UnQL. User can optionally specify
the source metamodel and target metamodel in KM3. Once they are loaded, forwardToward bidirectionalization of ATL with GRoundTram

source graphbidirectional evaluator

9target graphFig. 7. GRoundTram system

Fig. 8. Screenshot of GRoundTram Systemtransformation can be conducted by pushing “forward” button (right arrow icon). The
target graph appears on the right pane. User can graphically edit the target graph andapply backward transformation by pushing “backward” button (left arrow icon). Source
graph can be edited as well, of course. Metamodel conformance of the source and thetarget can be checked any time by pushing check icon on both panes. The transformation
itself can also be statically checked: given source/target metamodel and transformation,
the system checks whether the target graph always conforms to given target metamodel.
If not, a counterexample graph is displayed.
Figure 8 also demonstrates the traceability between source and target (red part). If
the user selects subgraphs on either pane, then corresponding subgraphs on other pane
are also highlighted. This helps the user to predict modification on which part in thetarget will affect which part on the source, and vice versa.

3

Encoding and decoding between models and graph structures

In order to use the GRoundTram system we need to encode the models in UnQL language and decode the results back to models. Instead of giving algorithms for them,here we illustrate the encoding process using the model in Fig. 4.

10

Isao Sasano et al.

Corresponding to the encoding of the rules in Section 4, we encode the models byusing the constant pattern ClassName. For example, the component of the Class withname field ”Person” is encoded into the following UnQL graph structure.
g1 = {ClassName : {Class : {name : {′′ Person′′ : {}},
attr : g2 ,attr : g3 }}}}The graphs g2 and g3 are obtained encoding of the components with Attribute class asfollows.
g2 = {ClassName : {Attribute : {name : {′′ name′′ : {}},
owner : g1 ,type : g4 }}}g3 = {ClassName : {Attribute : {name : {′′ address′′ : {}},
owner : g1 ,type : g4 }}}The graph g4 , encoded as follows, is for the remaining component.
g4 = {ClassName : {Class : {name : {′′ String′′ : {}}}}
The above representation is informal one for giving intuitive understanding. Formally,
when encoding models with cycles as in Fig. 4, we use the cycle construct and markers
in UnCAL language [8], which we omit for simplifying the presentation.
One thing we should note is we have to be able to get the original model representations from the graph structures. The overall figure of our approach is summarized inFig. 9. The decoding process, which we omit, is performed naturally in the reverse wayof the encoding process.

source modeltarget model

source model in UnQL

target model in UnQL

Fig. 9. Overview of our system

4

Encoding ATL rules in UnQL

In this section we present the algorithm to encode a given ATL program into an UnQL
expression. An ATL program consists of rules, as we have shown in Section 2.1. OurToward bidirectionalization of ATL with GRoundTram

11

strategy for encoding is to transform each ATL rule into a function in the sfun constructin UnQL, by using the identifiers in the ATL rules when making an UnQL function.
We design the algorithm along the structure of the ATL language in the following.
The top level transformation function is atl2unql.
atl2unql (rule r from inPat to outPatSeq) =sfun r (inPat2arg inPat) = outPatSeq2unql outPatSeq
This function takes a rule in ATL and produces a function in UnQL language. Thisfunction is applied to rules in the ATL program, producing one function for each rule.
We use the name of the rule as the name of the function. The inPat is the patternspecifying to which components the rule is applied. We transform this part by applying
inPat2arg, which produces a pattern that appears as the argument of the UnQL function. As we will mention in Section 3, each component in the model is encoded in UnQL
graph structure so that the function can find the encoded components by pattern matching. For this purpose we encode each component using the constant pattern ClassName.
So we define inPat2arg to produce the pattern including the constant ClassName. The
pattern s : A in ATL is just encoded to the reversed pattern {A : $s} since we encode
the model in the reverse order. The symbol $ is just used for clarifying the variable
pattern in the UnQL language.
inPat2arg (s : A) = {ClassName : {A : $s}}
The transformation function outPatSeq2unql is applied to outPatSeq in the rule.
The output pattern outP at in ATL specifies each of the produced components. A rule
may produce one or more components in the target model from a component in thesource model, although the example in Fig. 1 produces just one component. The variables t1 , t2 , . . ., each of which is bound to some component in the target model, may be
used in the output patterns outP atSeq. We encode the rule into a mutually recursivefunctions in UnQL, where we use the name of the variables t1 , t2 , . . . in the encoded
UnQL expression. Since in UnQL the value of the result of application of the function
should be a graph, we just select one variable t1 from the variables t1 , t2 , . . ..
outPatSeq2unql (t1 : ty1 (binds1 ), t2 : ty2 (binds2 ), . . .) =letrec t1 = outPat2unql (ty1 (binds1 ))t2 = outPat2unql (ty2 (binds2 ))
...
in t1
The function outPat2unql is applied to each output patterns. An output patternconsists of an identifier and a tuple of bindings. The identifier determines the class ofthe output pattern, so we attach the constant pattern ClassName.
outPat2unql (B (bind1, bind2, . . .)) ={ClassName : {B : (bind2unql bind1 ) ∪ (bind2unql bind2 ) ∪ . . .}}bind2unql (m ← oclExp) =select {m : $g}where oclExp2unqlBinds $g oclExp

12Isao Sasano et al.

The right-hand side of each binding is a subset of OCL expressions. The bindings
are transformed and put in the where clause of the select-where construct in UnQL. We
produce the bindings by applying the function oclExp2unqlBinds, defined as follows.
oclExp2unqlBinds p v = p in $v
oclExp2unqlBinds p (vs . v) = oclExp2unqlBinds $g vs ($g : fresh){v : p} in $g
oclExp2unqlBinds p string = p in {string : {}}oclExp2unqlBinds p (e1 + e2) = oclExp2unqlBinds {$l1 : {}} e1
oclExp2unqlBinds {$l2 : {}} e2
p in {$l1 ++ $l2 : {}}One thing to note here is the sequence of ids separated by dot is encoded by sequence of bindings, where fresh variables are introduced for each binding. Anotherthing to note is that string concatenation is encoded in the string concatenation in UnQL,
which is represented by ++ here.
By applying the algorithm above to the ATL example in Fig. 1, we obtain the UnQL
functions in Fig. 10. Note that dummy is used as a dummy label for making mutually
recursive functions. Note also that the actual UnQL does not allow patterns of generalform in the argument part but here we used them for simplifying the presentation as
we mentioned in Section 2.2. After obtained these functions, we apply these functions
recursively to the encoded source model. We define the following functions to do thisapplication.

sfun mapClass2Table ({ClassName : $g}) = f1 $g| mapClass2Table {$l : $g} = {$l : mapClass2Table $g}sfun f1 ({Class : $g}) =Class2Table ({ClassName : {Class : mapClass2Table $g}})| f1 {$l : $g} = {$l : mapClass2Table $g}sfun mapAttribute2Column (ClassName : $g}) = f2 $g| mapAttribute2Column {$l : $g} = {$l : mapAttribute2Column $g}
sfun f2 ({Attribute : $g}) =Attribute2Column ({ClassName : {Attribute : mapAttribute2Column $g}})| f2 {$l : $g} = {$l : mapAttribute2Column $g}
Then we apply these functions to the encoded source model as follows.
mapAttribute2Column (mapClass2Table $db)
Here $db represents the encoded source model. We omit the algorithm for generatingthese functions since it is fairly straightforward.
We have implemented the algorithm in a functional language called OCaml. The
complexity of the algorithm is linear in the size of the input model and the rule descriptions. For the examples given in this paper, the program in OCaml works well.

Toward bidirectionalization of ATL with GRoundTram

13

sfun Class2Table ({ClassName:{Class:$s}}) =letrecsfun t ({_:{}}) ={ClassName:{Table:select {name:$a}
where $b in $s,{name:$a} in $bUselect {col:$c}
where $d in $s,{attr:$c} in $d}}
in t({dummy:{}})
sfun Attribute2Column ({ClassName:{Attribute:$s}}) =letrecsfun t ({_:{}}) ={ClassName:{Column:select {name:$a}
where $b in $s,{name:$a} in $b}}
in t({dummy:{}})

Fig. 10. UnQL functions obtained by encoding the example ATL

5Conclusions

In this paper we presented an approach to bidirectionalizing a subset of ATL. Althoughsmall, the core part of the ATL is shown to be bidirectionalized. The prototype implementation in OCaml is available at http://www.biglab.org/src/icmt11/index.
html. The program works by putting it in the src directory in the source code of the
GRoundTram system. This work is a first step toward realizing a practical bidirectionalmodel transformations. We believe this approach is promising and in the future we willfurther develop it on the settings with less restrictions on the ATL transformations.

Acknowledgments
We would like to thank Massimo Tisi and Frederic Jouault for valuable discussions andfor providing us simple examples of ATL rules. The research was supported in partby the Grand-Challenging Project on “Linguistic Foundation for Bidirectional Model

14

Isao Sasano et al.

Transformation” from the National Institute of Informatics, Grant-in-Aid for Scientific
Research (B) No. 22300012, Grant-in-Aid for Scientific Research (C) No. 20500043,
and Encouragement of Young Scientists (B) of the Grant-in-Aid for Scientific Research
No. 20700035.

References
1. The ATL web site. http://www.eclipse.org/m2m/atl/.
2. The BiG project web site. http://www.biglab.org/.
3. ATLAS group. KM3: Kernel MetaMetaModel manual. http://www.eclipse.org/gmt/
atl/doc/.
4. François Bancilhon and Nicolas Spyratos. Update semantics of relational views. ACM Transactions on Database Systems, 6(4):557–575, 1981.
5. Davi M. J. Barbosa, Julien Cretin, Nate Foster, Michael Greenberg, and Benjamin C. Pierce.
Matching lenses: Alignment and view update. In ACM SIGPLAN International Conference
on Functional Programming, pages 193–204. ACM, 2010.
6. Jean Bezivin, Bernhard Rumpe, Andy Schürr, and Laurence Tratt. Model transformationin practice workshop announcement. In Satellite Events at the MoDELS 2005 Conference,
pages 120–127. Springer-Verlag, 2005.
7. Aaron Bohannon, Benjamin C. Pierce, and Jeffrey A. Vaughan. Relational lenses: a language
for updatable views. In Stijn Vansummeren, editor, PODS, pages 338–347. ACM, 2006.
8. Peter Buneman, Mary F. Fernandez, and Dan Suciu. UnQL: a query language and algebra forsemistructured data based on structural recursion. VLDB Journal: Very Large Data Bases,
9(1):76–110, 2000.
9. Krzysztof Czarnecki, J. Nathan Foster, Zhenjiang Hu, Ralf Lämmel, Andy Schürr, andJames F. Terwilliger. Bidirectional transformations: A cross-discipline perspective. In International Conference on Model Transformation (ICMT 2009), pages 260–283. LNCS 5563,
Springer, 2009.
10. J. Nathan Foster, Michael B. Greenwald, Jonathan T. Moore, Benjamin C. Pierce, and Alan
Schmitt. Combinators for bi-directional tree transformations: a linguistic approach to theview update problem. In POPL ’05: ACM SIGPLAN–SIGACT Symposium on Principles ofProgramming Languages, pages 233–246, 2005.
11. Soichiro Hidaka, Zhenjiang Hu, Kazuhiro Inaba, Hiroyuki Kato, Kazutaka Matsuda, andKeisuke Nakano. Bidirectionalizing graph transformations. In ACM SIGPLAN International
Conference on Functional Programming, pages 205–216. ACM, 2010.
12. Soichiro Hidaka, Zhenjiang Hu, Hiroyuki Kato, and Keisuke Nakano. Towards a compositional approach to model transformation for software development. In SAC’09: Proceedingsof the 2009 ACM symposium on Applied Computing, pages 468–475, New York, NY, USA,2009. ACM.
13. Zhenjiang Hu, Shin-Cheng Mu, and Masato Takeichi. A programmable editor for developing
structured documents based on bidirectional transformations. Higher-Order and Symbolic
Computation, 21(1-2):89–118, 2008.
14. Frederic Jouault, Freddy Allilaire, Jean Bezivin, and Ivan Kurtev. Atl: A model transformation tool. Science of Computer Programming, 72(1-2):31–39, 2008.
15. Frederic Jouault and Ivan Kurtev. Transforming models with ATL. In Proceedings of Satellite
Events at the MoDELS 2005 Conference, pages 128–138. LNCS 3844, Springer, 2006.
16. Kazutaka Matsuda, Zhenjiang Hu, Keisuke Nakano, Makoto Hamana, and Masato Takeichi.
Bidirectionalization transformation based on automatic derivation of view complement functions. In 12th ACM SIGPLAN International Conference on Functional Programming (ICFP
2007), pages 47–58. ACM Press, October 2007.

Toward bidirectionalization of ATL with GRoundTram

15

17. Perdita Stevens. Bidirectional model transformations in QVT: Semantic issues and open
questions. In Gregor Engels, Bill Opdyke, Douglas C. Schmidt, and Frank Weil, editors,
Proc. 10th MoDELS, volume 4735 of Lecture Notes in Computer Science, pages 1–15.
Springer, 2007.
18. Janis Voigtländer. Bidirectionalization for free! (pearl). In POPL ’09: ACM SIGPLAN–
SIGACT Symposium on Principles of Programming Languages, pages 165–176, New York,NY, USA, 2009. ACM.
19. Janis Voigtländer, Zhenjiang Hu, Kazutaka Matsuda, and Meng Wang. Combining syntactic
and semantic bidirectionalization. In ACM SIGPLAN International Conference on Functional Programming, pages 181–192. ACM, 2010.
20. Yingfei Xiong, Dongxi Liu, Zhenjiang Hu, Haiyan Zhao, Masato Takeichi, and Hong Mei.
Towards automatic model synchronization from model transformations. In 22nd IEEE/ACM
International Conference on Automated Software Engineering (ASE 2007), pages 164–173.
ACM Press, November 2007.