ATL tutorial - EclipseCon 2009
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

ATL tutorial - EclipseCon 2009

on

  • 8,289 views

EclipseCon 2009 ATL tutorial - Model refactoring with ATL

EclipseCon 2009 ATL tutorial - Model refactoring with ATL

Statistics

Views

Total Views
8,289
Views on SlideShare
8,254
Embed Views
35

Actions

Likes
3
Downloads
303
Comments
0

3 Embeds 35

http://www.slideshare.net 20
http://andionline.posterous.com 14
http://www.slashdocs.com 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

ATL tutorial - EclipseCon 2009 Presentation Transcript

  • 1. Model Refactoring and other Advanced ATL Techniques Frédéric Jouault (INRIA) William Piers (Obeo) © 2009 by INRIA, Obeo; made available under the EPL v1.0 | 23 March 2009
  • 2. What You Will Learn in This Tutorial • Refactoring models efficiently • Compiling a DSL for SWTBot • Visualizing models 2 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 3. Discussion Topics • About ATL  ATL versions (2004 vs. 2006), notably refining mode  Best Practices  Model Transformation Virtual Machines  ATL vs. QVT • Around ATL  M2M vs. M2T  Where do models come from?  Modeling platforms – AmmA  Domain-Specific Languages and Modeling  You can vote for the topics you are most interested in (2 or 3)  You may suggest additional topics 3 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 4. Agenda • Introduction  Model-To-Model transformation in the MDE field  M2M vs. M2T • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 4 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 5. ATL - Description • ATL : ATLAS Transformation Language • ATL is a language and a virtual machine dedicated to model transformation • ATL is an Eclipse Model-to-Model (M2M) component, inside of the Eclipse Modeling Project (EMP) 5 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 6. Definitions • A model transformation is the automatic creation of target models from source models. • Applications*:  Interoperability of Telephony Languages  Modeling Web applications  Converting graphics (e.g., Rational Rose to UML2 Tools)  Measuring and verifying UML models  etc. Whatever your problem, you can write a lot of Java code or a (generally) much simpler ATL transformation. * Use cases available at: http://www.eclipse.org/m2m/atl/usecases/ 6 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 7. Operational context: small theory conformsTo Metametamodel Class Class conformsTo conformsTo MMa ATL MMb Class Class Class Green Rule Blue Class Class Red MMa2MMb.atl Pink Rule Rule conformsTo R2B G2P conformsTo Ma Mb 7 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 8. Operational context of ATL MOF MMa is the MMB is the source target metamodel MMa ATL MMb metamodel MMa2MMb.atl Ma Mb Ma is the source model Mb is the target model 8 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 9. M2M vs. M2T • M2M: Model To Model transformation  Abstract syntax to abstract syntax  Languages: ATL, QVT Operational, QVT Relations • M2T: Model To Text transformation  Abstract syntax to concrete syntax  Languages: JET, xPand • TMF: Textual Modeling Framework  Abstract syntax to and from concrete syntax  Languages: TCS, xText • This tutorial is focused on M2M 9 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 10. Agenda • Introduction • ATL Overview  Available resources: wiki, zoo, newsgroup, use cases, etc.  ATL language description • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 10 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 11. ATL history • 1990 : first works on model transformation • 1998 : initial publication for a Ph.D. thesis at the University of Nantes • 1998 - 2004 : Implementation  CARROLL/MOTOR project (CEA, Thales, INRIA)  Collaborative projects : ModelWare, ModelPlex, OpenEmbeDD • 2004 : Eclipse GMT integration • 2006 : Industrial solution inside of the Eclipse M2M project 11 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 12. ATL community • Active community  Newsgroup: news://news.eclipse.org/eclipse.modeling.m2m  Wiki: http://wiki.eclipse.org/ATL  Bugzilla  Use cases: http://www.eclipse.org/m2m/atl/usecases/  Transformations zoo (i.e., a library): http://www.eclipse.org/m2m/atl/atlTransformations/ • Other links  Project page: http://www.eclipse.org/m2m/atl/ 12 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 13. ATL documentation • For a long time, ATL doc was dispatched over several places  ATL User Manual, out of date  ATL wiki, disorganized  Some information in newsgroup, mailing lists... • Now merged into ATL wiki http://wiki.eclipse.org/ATL/User_Guide • Use of Mylyn Wikitext tool to generate Eclipse Help • Eclipse Help produces a portable, printable, searchable documentation support 13 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 14. ATL documentation Mylyn WikiText Eclipse Wiki extraction to collaborative Eclipse Help edition 14 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 15. ATL overview • Source models and target models are distinct:  Source models are read-only (they can only be navigated, not modified),  Target models are write-only (they cannot be navigated). • The language is a declarative-imperative hybrid:  Declarative part:  Matched rules with automatic traceability support,  Side-effect free navigation (and query) language: OCL 2.0  Imperative part:  Called rules,  Action blocks. • Recommended programming style: declarative 15 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 16. ATL overview (continued) • A declarative rule specifies:  a source pattern to be matched in the source models,  a target pattern to be created in the target models for each match during rule application. • An imperative rule is basically a procedure:  It is called by its name,  It may take arguments,  It can contain:  A declarative target pattern,  An action block (i.e. a sequence of statements),  Both. 16 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 17. ATL overview (continued) • Applying a declarative rule means:  Creating the specified target elements,  Initializing the properties of the newly created elements. • There are three types of declarative rules:  Standard rules that are applied once for each match,  A given set of elements may only be matched by one standard rule,  Lazy rules that are applied as many times for each match as it is referred to from other rules (possibly never for some matches),  Unique lazy rules that are applied at most once for each match and only if it is referred to from other rules. 17 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 18. Declarative rules: source pattern • The source pattern is composed of:  A labeled set of types coming from the source metamodels,  A guard (Boolean expression) used to filter matches . • A match corresponds to a set of elements coming from the source models that:  Are of the types specified in the source pattern (one element for each type),  Satisfy the guard. 18 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 19. Declarative rules: target pattern • The target pattern is composed of:  A labeled set of types coming from the target metamodels,  For each element of this set, a set of bindings.  A binding specifies the initialization of a property of a target element using an expression. • For each match, the target pattern is applied:  Elements are created in the target models (one for each type of the target pattern),  Target elements are initialized by executing the bindings:  First evaluating their value,  Then assigning this value to the corresponding property. 19 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 20. Execution order of declarative rules • Declarative ATL frees the developer from specifying execution order:  The order in which rules are matched and applied is not specified.  Remark: the match of a lazy or unique lazy rules must be referred to before the rule is applied.  The order in which bindings are applied is not specified. • The execution of declarative rules can however be kept deterministic:  The execution of a rule cannot change source models  It cannot change a match,  Target elements are not navigable  The execution of a binding cannot change the value of another. 20 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 21. Example: ClassDiagram to Relational – Overview • The source metamodel ClassDiagram is a simplification of class diagrams. • The target metamodel Relational is a simplification of the relational model.  ATL declaration of the transformation: module ClassDiagram2Relational; create Mout : Relational from Min : ClassDiagram; • The transformation excerpts used in this presentation come from: http://www.eclipse.org/m2m/atl/atlTransformations/#Class2Relational 21 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 22. Source Metamodel: ClassDiagram NamedElement +name : String Classifier +type DataType Class +attr Attribute +multivalued : Boolean owner * {ordered } 22 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 23. Target Metamodel: Relational Named +name:String Table + col Column * + type Type + owner * { ordered } + keyOf 0..1 + key * 23 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 24. Sample Source and Target Models Class2Table SingleValuedAttribute2Column MultiValuedAttribute2Column 24 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 25. ClassDiagram2Relational.atl – overview NamedElement +name : String Class2Table SingleValuedAttribute2Column MultiValuedAttribute2Column Classifier +type Named DataType Class Attribute +name:String +attr +multivalued : Boolean owner * { ordered } Table + col Column * + type Type + owner * {ordered } + keyOf 0..1 + key * 25 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 26. ClassDiagram2Relational.atl – overview • Informal description of rules  Class2Table:  A table is created from each class,  The columns of the table correspond to the single-valued attributes of the class,  A column corresponding to the key of the table is created.  SingleValuedAttribute2Column:  A column is created from each single-valued attribute.  MultiValuedAttribute2Column:  A table with two columns is created from each multi-valued attribute,  One column refers to the key of the table created from the owner class of the attribute,  The second column contains the value of the attribute. 26 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 27. Rule Class2Table (1 Of 4) • For each Class, create a Table : rule Class2Table { from -- source pattern c : ClassDiagram!Class to -- target pattern t : Relational!Table } 27 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 28. Rule Class2Table (2 Of 4) • The name of the Table is the name of the Class: rule Class2Table { from c : ClassDiagram!Class to t : Relational!Table ( name <- c.name -- a simple binding ) } 28 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 29. Rule Class2Table (3 Of 4) • The columns of the table correspond to the single-valued attributes of the class: rule Class2Table { from c : ClassDiagram!Class to t : Relational!Table ( name <- c.name, col <- c.attr->select(e | -- a binding not e.multiValued -- using complex ) -- navigation ) } • Remark: attributes are automatically resolved into columns by automatic traceability support. 29 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 30. Rule Class2Table (4 Of 4) • Each Table owns a key containing a unique identifier: rule Class2Table { from c : ClassDiagram!Class to t : Relational!Table ( name <- c.name, col <- c.attr->select(e | not e.multiValued )->union(Sequence {key}), key <- Set {key} ), key : Relational!Column ( -- another target name <- ‘Id’ -- pattern element ) -- for the key 30 } Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 31. Rule SingleValuedAttribute2Column • For each single-valued Attribute create a Column: rule SingleValuedAttribute2Column { from -- the guard is used for selection a : ClassDiagram!Attribute (not a.multiValued) to c : Relational!Column ( name <- a.name ) } 31 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 32. Rule MultiValuedAttribute2Column • For each multi-valued Attribute create a Table, which contains two columns:  The identifier of the table created from the class owner of the Attribute  The value. rule MultiValuedAttribute2Column { id : Relational!Column ( from a : ClassDiagram!Attribute (a.multiValued) name <- ‘Id’ to ), t : Relational!Table ( value : Relational!Column ( name <- a.owner.name + ‘_’ + a.name, name <- a.name col <- Sequence {id, value} ) ), } 32 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 33. Object Constraint Language (OCL) • Originally intended to express constraints over UML models, for instance: context Person inv: self.age > 0 • Extended to query any model • Used in several transformation languages (e.g., ATL, QVT) to compute values from the source models • Specification:  The version on which ATL is based is available from: http://www.omg.org/docs/ptc/03-10-14.pdf  Section 7: language overview  Section 11: standard library  Section 11.8: iterator expressions 33 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 34. ATL/OCL types hierarchy 34 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 35. Running ATL/OCL Queries Within Eclipse • Considering a given OCL expression, such as: 5 mod 2 • Place it in an ATL query, for instance in file TestQuery.atl: query TestQuery = (5 mod 2).debug('Result'); • Where the call to OclAny.debug(String) : OclAny:  Does not change the result (it returns the value on which it is called)  Prints the result on the console  This operation may be called anywhere (e.g., to print intermediate values) • Advantages:  May query any model  May use debugger • Drawbacks:  Cannot specify a context 35 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 36. Iterator Expressions Returning Collections • collect Query: Sequence {1, 2, 3, 4}->collect(e | e + 2) Result: Sequence {3, 4, 5, 6} • reject Query: Sequence {1, 2, 3, 4}->reject(e | e > 2) Result: Sequence {1, 2} • select Query: Sequence {1, 2, 3, 4}->select(e | e > 2) Result: Sequence {3, 4} • sortedBy Query: Sequence {3, 4, 1, 2}->sortedBy(e | e) Result: Sequence {1, 2, 3, 4} 36 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 37. Predicate Iterator Expressions Admitting Multiple Iterators • exists Sequence {1, 2, 3, 4}->exists(e | true e > 2) Sequence • forAll {1, 2, 3, 4}->exists(e | fals e < 1) e Sequence {1, 2, 3, 4}->exists(e, | true Sequence {1, 2, 3, 4}->forAll(e false f |> 2) f + 3) e e= Sequence {1, 2, 3, 4}->forAll(e | true e > 0) 37 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 38. Other Iterator Expressions with One Iterator • any Query: Set{1, 2, 3, 4}->any(e | e > 2) Result: 3 Query: Set{1, 2, 3, 4}->any(e | e > 2) Result: 4 • isUnique Query: Sequence {1, 2, 3, 4}->isUnique(e | e mod 2 = 1) Result: false (Sequence {1, 0, 1, 0} contains duplicates) Query: Sequence {1, 2, 3, 4}->isUnique(e | e) Result: true • one Query: Set{1, 2, 3, 4}->one(e | e > 2) Result: false 38 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 39. Iterate Expression • Enables computation of any value from a collection • Example: Sequence {'one', 'two', 'three'}->iterate(e; acc : String = '(' | acc + if acc = '(' then '' else ', 'endif + e ) + ')' Result: '(one, two, three)' • Description:  The accumulator is initialized  For each element in the source:  The iterator gets the value of this element  The body is evaluated  The accumulator receives the resulting value  The result is the value of the accumulator at the end of the iteration 39 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 40. ATL editor 40 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 41. ATL content assist • ADT (ATL Development Tools) has recently been improved with basic content assist  Type completion  Left-side bindings completion  Basic code templates 41 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 42. ATL Launch Configuration 42 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 43. Launching ATL using ANT • Historically provided by GMT/AM3 • A new set of tasks is directly available into ATL 3.0  Very close to the old AM3 tasks  am3.saveModel => atl.saveModel  am3.loadModel => atl.loadModel  am3.atl => atl.launch  Allows to specify transformation launching with more parameters  Specific Injector/Extractor • Provide a way to chain transformations 43 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 44. Launching ATL using ANT <project name="ClassDiagram2Relational" default="main"> <property name="source" value="ClassDiagram/Sample-ClassDiagram.xmi"/> <property name="target" value="Relational/Sample-Relational.xmi"/> <target name="main" depends="loadMetamodels"> <atl.loadModel modelHandler="EMF" name="myClassDiagram" metamodel="ClassDiagram" path="${source}"/> <atl.launch path="ATLFiles/ClassDiagram2Relational.atl"> <inModel name="ClassDiagram" model="ClassDiagram"/> <inModel name="IN" model="myClassDiagram"/> <inModel name="Relational" model="Relational"/> <outModel name="OUT" model="myRelational" metamodel="Relational"/> </atl.launch> <atl.saveModel model="myRelational" path="${target}"/> </target> <target name="loadMetamodels"> <atl.loadModel modelHandler="EMF" name="ClassDiagram" metamodel="%EMF" path="ClassDiagram/ClassDiagram.ecore"/> <atl.loadModel modelHandler="EMF" name="Relational" metamodel="%EMF" path="Relational/Relational.ecore" /> </target> </project> 44 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 45. Agenda • Introduction • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 45 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 46. First exercise: Model Visualization • Context  UML models (but general approach) • Objective  provide a different way to visualize models  applications in reverse engineering cartography • A visualization tool: prefuse (http://prefuse.org/)  Advanced / dynamic visualizations  BSD license  Accepts many data formats as input  GraphML  TreeML 46 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 47. First exercise: Model Visualization • Overview: UML Model Prefuse visualization 47 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 48. Agenda • Introduction • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Simple and Efficient Refactoring Transformations • Model Enrichment • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 48 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 49. Writing Interpreters in ATL • An ATL interpreter typically evaluates a model into a value.  Example: simple expressions. • Evaluation may involve input data that is not part of the model:  Example: XPath expressions evaluates over an XML model. • The interpreter may be part of a larger transformation. • How to write an evaluator:  Define an evaluation helper on each metamodel class to evaluate. 49 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 50. Example: Metamodel for Simple Expressions Expression +right +left IntegerExp OperatorExp +value : Integer +operator : String 50 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 51. ATL Interpreter for Simple Expressions query CalcEval = let root : Calc!Expression.allInstances()->any(e | -- select root e.refImmediateComposite().oclIsUndefined()) in root.eval().debug('Result'); -- evaluate helper context Calc!IntegerExp def: eval() : Integer = self.value; helper context Calc!OperatorExp def: eval() : Integer = if self.operator = '+' then self.left.eval() + self.right.eval() else if self.operator = '*' then self.left.eval() * self.right.eval() else self.operator.debug('UnsupportedOperator') endif endif; 51 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 52. Simple Expressions in Java (1 Of 3) abstract class Expression { public abstract int eval(); } class IntegerExp extends Expression { int value; public IntegerExp(int value) { this.value = value; } public int eval() { return value; } } 52 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 53. Simple Expressions in Java (2 Of 3) class OperatorExp extends Expression { Expression left; String operator; Expression right; public OperatorExp(Expression left, String operator, Expression right) { this.left = left; this.operator = operator; this.right = right; } public int eval() { int ret = 0; if("+".equals(operator)) { ret = left.eval() + right.eval(); } else if("*".equals(operator)) { ret = left.eval() * right.eval(); } else { System.err.println("Unsupported operator: " + operator); System.exit(1); } return ret; } } 53 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 54. Simple Expressions in Java (3 Of 3) public class TestExpression { public static void main(String args[]) { System.out.println( // evaluating 1 + 4 * 3 new OperatorExp( new IntegerExp(1), "+", new OperatorExp( new IntegerExp(4), "*", new IntegerExp(3) ) ).eval() ); } } 54 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 55. Writing Serializers in ATL • A serializer transforms a source model into a String. • It is a special kind of interpreter that evaluates into a String representing the evaluated model. • Pros:  Any string may be computed (e.g., XML, HTML).  Easily usable from within a transformation (e.g., when parts of the source model correspond to strings in the target model). • Cons:  A TCS syntax specification can already be used for serialization.  Some complex syntactic rules (e.g., proper parenthesizing of expressions) are hard to represent (but TCS does it 55 automatically). Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 56. Example: ATL Serializer for Simple Expressions query CalcEval = let root : Calc!Expression.allInstances()->any(e | -- select root e.refImmediateComposite().oclIsUndefined()) in root.serialize().debug('Result'); -- serialize helper context Calc!IntegerExp def: serialize() : String = self.value.toString(); helper context Calc!OperatorExp def: serialize() : String = '(' + self.left.serialize() + ' ' + self.operator + ' ' + self.right.serialize() + ')'; 56 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 57. Simple copy -- Source metamodel: MMA -- Target metamodel: MMB class A1 { class B1 { attribute v1 : String; attribute v1 : String; attribute v2 : String; attribute v2 : String; } } module MMAtoMMB; create OUT : MMB from IN : MMA; rule A1toB1 { from s : MMA!A1 to t : MMB!B1 ( v1 <- s.v1, v2 <- s.v2 ) } 57 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 58. Structure creation -- Source metamodel: MMA -- Target metamodel: MMB class A1 { class B1 { reference b2 : B2; attribute v1 : String; reference b3 : B3; } attribute v2 : String; class B2 { attribute v1 : String; } } class B3 { attribute v2 : String; } module MMAtoMMB; t2 : MMB!B2 ( create OUT : MMB from IN : MMA; v1 <- s.v1 rule A1toB1andB2andB3 { ), from t3 : MMB!B3 ( s : MMA!A1 v2 <- s.v2 to ) t1 : MMB!B1 ( } b2 <- t2, b3 <- t3 ), 58 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 59. Structure simplification -- Source metamodel: MMA -- Target metamodel: MMB class A1 { reference a2 : A2; class B1 { reference a3 : A3; } attribute v1 : String; class A2 { attribute v1 : String; } attribute v2 : String; class A3 { attribute v2 : String; } } module MMAtoMMB; create OUT : MMB from IN : MMA; rule A1toB1 { from s : MMA!A1 to t : MMB!B1 ( v1 <- s.a2.v1, v2 <- s.a3.v2 ) } 59 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 60. Structure simplification (needlessly more complex) -- Source metamodel: MMA -- Target metamodel: MMB class A1 { reference a2 : A2; class B1 { reference a3 : A3; } attribute v1 : String; class A2 { attribute v1 : String; } attribute v2 : String; class A3 { attribute v2 : String; } } module MMAtoMMB; create OUT : MMB from IN : MMA; rule A1toB1 { from s1 : MMA!A1, s2 : MMA!A2, s3 : MMA!A3 (s1.a2 = s2 and s1.a3 = s3) to t : MMB!B1 ( v1 <- s.a2.v1, v2 <- s.a3.v2 ) } 60 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 61. Traceability: implicit resolution of default elements -- Source metamodel: MMA -- Target metamodel: MMB class A1 { reference a2 : A2; class B1 { reference b2 : B2; reference a3 : A3; } reference b3 : B3; } class A2 { attribute v1 : String; } class B2 { attribute v1 : String; } class A3 { attribute v2 : String; } class B3 { attribute v2 : String; } module MMAtoMMB; rule A2toB2 { create OUT : MMB from IN : MMA; from s : MMA!A2 rule A1toB1 { to t : MMB!B2 ( from v1 <- s.v1 ) s : MMA!A1 } to rule A3toB3 { t : MMB!B1 ( from s : MMA!A3 b2 <- s.a2, -- HERE to t : MMB!B3 ( b3 <- s.a3 -- HERE v2 <- s.v2 ) ) } } 61 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 62. Remark: same result, less modular -- Source metamodel: MMA -- Target metamodel: MMB class A1 { reference a2 : A2; class B1 { reference b2 : B2; reference a3 : A3; } reference b3 : B3; } class A2 { attribute v1 : String; } class B2 { attribute v1 : String; } class A3 { attribute v2 : String; } class B3 { attribute v2 : String; } module MMAtoMMB; t2 : MMB!B2 ( create OUT : MMB from IN : MMA; v1 <- s.a2.v1 rule A1toB1 { ), from t3 : MMB!B3 ( s : MMA!A1 v2 <- s.a3.v2 to ) t1 : MMB!B1 ( } b2 <- t2, b3 <- t3 ), 62 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 63. Traceability: resolveTemp for additional elements -- Source metamodel: MMA -- Target metamodel: MMB class A1 { reference a2 : A2; } class B1 { reference b2 : B2; class A2 { attribute v1 : String; reference b3 : B3; } attribute v2 : String; } class B2 { attribute v1 : String; } class B3 { attribute v2 : String; } module MMAtoMMB; rule A2toB2andB3 { create OUT : MMB from IN : MMA; from rule A1toB1 { s : MMA!A2 from s : MMA!A1 to to t1 : MMB!B2 ( t : MMB!B1 ( v1 <- s.v1 b2 <- s.a2, ), b3 <- t2 : MMB!B3 ( thisModule.resolveTemp(s.a2, 't2') v2 <- s.v2 ) ) } 63 } Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 64. Traceability: resolveTemp even for first element -- Source metamodel: MMA -- Target metamodel: MMB class A1 { reference a2 : A2; } class B1 { reference b2 : B2; class A2 { attribute v1 : String; reference b3 : B3; } attribute v2 : String; } class B2 { attribute v1 : String; } class B3 { attribute v2 : String; } module MMAtoMMB; rule A2toB2andB3 { create OUT : MMB from IN : MMA; from rule A1toB1 { s : MMA!A2 from s : MMA!A1 to to t : MMB!B1 ( t1 : MMB!B2 ( b2 <- -- possible but complex v1 <- s.v1 thisModule.resolveTemp(s.a2, 't1'), ), b3 <- t2 : MMB!B3 ( thisModule.resolveTemp(s.a2, 't2') v2 <- s.v2 ) ) } 64 } Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 65. Structure creation revisited with resolveTemp -- Source metamodel: MMA -- Target metamodel: MMB class A1 { class B1 { reference b2 : B2; attribute v1 : String; reference b3 : B3; } attribute v2 : String; class B2 { attribute v1 : String; } } class B3 { attribute v2 : String; } module MMAtoMMB; t2 : MMB!B2 ( create OUT : MMB from IN : MMA; v1 <- s.v1 rule A1toB1andB2andB3 { ), from t3 : MMB!B3 ( s : MMA!A1 v2 <- s.v2 to ) t1 : MMB!B1 (-- possible but complex } b2 <- thisModule.resolveTemp(s, 't2'), b3 <- thisModule.resolveTemp(s, 't3') ), 65 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 66. Kinds of matched (declarative) rules • We have only seen standard rules in default mode so far. Kind of Number of Number of Kind of rule references times the traceability to source target pattern link pattern gets created created standard 0 1 default or 1 1 not (using keyword n>1 1 nodefault) unique 66 0 0 Not default Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 67. Syntax of the different kinds of matched rules Kind of rule Definition Reference standard rule R1 { <value of type default from s : MMA!A1> MMA!A1 or to t : MMB! <collection of B1 } MMA!A1> standard nodefault rule not currently nodefault R1 { possible (1) For collections: aCollection->collect(e | thisModule.R1(e)) from s : 67 MMA!A1 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 68. Rule inheritance • Rule inheritance, to help structure transformations and reuse rules and patterns:  A child rule matches a subset of what its parent rule matches,  All the bindings of the parent still make sense for the child,  A child rule specializes target elements of its parent rule:  Initialization of existing elements may be improved or changed,  New elements may be created,  Syntax: abstract rule R1 { -- ... } rule R2 extends R1 { -- ... } 68 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 69. Copy class inheritance without rule inheritance -- Source metamodel: MMA -- Target metamodel: MMB class A1 { attribute v1 : String; } class B1 { attribute v1 : String; } class A2 extends A1 { class B2 extends B1 { attribute v2 : String; attribute v2 : String; } } module MMAtoMMB; rule A2toB2 { create OUT : MMB from IN : MMA; from rule A1toB1 { s : MMA!A2 from to s : MMA!A1 t : MMB!B2 ( to v1 <- s.v1, t : MMB!B1 ( v2 <- s.v2 v1 <- s.v1 ) ) } } 69 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 70. Copy class inheritance with rule inheritance -- Source metamodel: MMA -- Target metamodel: MMB class A1 { attribute v1 : String; } class B1 { attribute v1 : String; } class A2 extends A1 { class B2 extends B1 { attribute v2 : String; attribute v2 : String; } } module MMAtoMMB; rule A2toB2 extends A1toB1 { create OUT : MMB from IN : MMA; from rule A1toB1 { s : MMA!A2 from to s : MMA!A1 t : MMB!B2 ( to -- v1 <- s.v1, t : MMB!B1 ( v2 <- s.v2 v1 <- s.v1 ) ) } } 70 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 71. Guidelines Make your transformation as complex as necessary but as simple as possible. • Prefer declarative over imperative: only use imperative for the part of a transformation that needs it if it even does. • Prefer simpler constructs over more complex ones:  Use standard rules when possible, otherwise use unique lazy rules, and use lazy rules only if necessary.  Only use resolveTemp if necessary.  Prefer iterators (e.g., select, collect) over iterate. 71 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 72. Refactoring Transformations – Example • Public2Private:  Making every public Property private  Leaving the rest of the model unchanged • Note: although this example uses UML, the approach presented here is metamodel-independent. 72 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 73. Operational context of ATL (Reminder) MOF MMa is the MMB is the source target metamodel MMa ATL MMb metamodel MMa2MMb.atl Ma Mb Ma is the source model Mb is the target model (read-only) (write-only) 73 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 74. Refactoring transformations – Overview • General characteristics:  Operate on a single metamodel (i.e., MMa = MMb)  Most of the model remains unchanged (i.e., Ma ≈ Mb) • Optional characteristics:  May apply to only a given part of the model (i.e., a selection)  Identity of elements may need to be preserved (e.g., in an editor, although usually not necessary if XMI-to-XMI) • Challenges:  Modification of an existing model (i.e., different from the general scheme)  Possible interactive usage (requires a certain performance level) 74 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 75. Implementation of Refactoring Transformations • Writing every rule  Simple, but not scalable: typically about one rule per metamodel element (e.g., 4153 lines of code for UML) • Modifying a generated copy transformation  Scales easily to a large number of metamodel elements, but important information is hidden • Superimposing a few rules on a copy transformation  Relatively elegant: the generated copy transformation is left untouched, refactoring rules are grouped into a separate module • Common issue of these approaches: they copy the source model elements into a different target model  Performance is not especially good, they do not scale to large models  Identity of elements is not preserved for use within an editor 75 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 76. UML Public2Private – Superimposition module Public2Private; Technique create OUT : UML2 from IN : UML2; rule Property { from rule Property { from s : UML2!Property ( s.visibility = #public to ) s : UML2!Property ( t : UML2!Property ( visibility <- #private, s.visibility = #public name <- s.name, ) to isLeaf <- s.isLeaf, isStatic <- s.isStatic, isOrdered <- s.isOrdered, isUnique <- s.isUnique, t : UML2!Property ( isReadOnly <- s.isReadOnly, isDerived <- s.isDerived, visibility <- #private, isDerivedUnion <- s.isDerivedUnion, aggregation <- s.aggregation, name <- s.name, eAnnotations <- s.eAnnotations, isLeaf <- s.isLeaf, … ownedComment <- s.ownedComment, clientDependency <- s.clientDependency, nameExpression <- s.nameExpression, type <- s.type, upperValue <- s.upperValue, lowerValue <- s.lowerValue, templateParameter <- s.templateParameter, end <- s.end, deployment <- s.deployment, templateBinding <- s.templateBinding, Superimposed on ownedTemplateSignature <- s.ownedTemplateSignature, redefinedProperty <- s.redefinedProperty, UML2Copy.atl defaultValue <- s.defaultValue, subsettedProperty <- s.subsettedProperty, (4153 generated lines) association <- s.association, qualifier <- s.qualifier } 76 ) Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 77. ATL Refining Mode • Challenges:  Keeping as much as possible of ATL semantics  Performance suitable for interactive usage  Preservation of elements identity • ATL 2004 refining mode:  Works as the approaches presented earlier: by copying source model elements to target model  Only rules that do not perform simple copy need to be specified, with all bindings (similar to superimposition but with an implicit copy transformation)  Keeps ATL semantics, but neither very performant, nor identity preserving 77 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 78. ATL 2006 Refining Mode • Works by performing in-place transformation Still keeps ATL semantics (i.e., write-only target model during rule execution)  Performs well-enough for interactive usage (see demo)  Preserves elements identity • Only rules and bindings that do perform changes need to be specified  Less verbose than previous techniques (including ATL 2004) 78 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 79. Public2Private in ATL 2006 Refining Mode module Public2Private; create OUT : UML refining IN : UML; rule Property { from s : UML!Property (s.visibility = #public) to t : UML!Property ( visibility <- #private ) } 79 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 80. What would happen in Standard Mode? module Public2Private; create OUT : UML from IN : UML; rule Property { from s : UML!Property (s.visibility = #public) to t : UML!Property ( visibility <- #private ) } 80 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 81. Public2Private.atl on j2se-1_2-api.uml (6.17MiB) Time (s) Bytecod Lines of Transformat Tota es code ion l Superimposi tion 2467779 209 216 41 7 Refining 3.20 11 354364 15 2.7 81 Ratio 65.3 19.6 69.6 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 82. Public2Private.atl on j2se-1_6-api.uml (13.14MiB) Time (s) Bytecod Lines of Transformat Tota es code ion l Superimposi tion 5247898 496 515 41 4 Refining 5.75 25 674874 15 2.7 82 Ratio 86.3 20.6 77.8 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 83. Public2Private plus Accessors rule Property { from s : UML!Property ( s.visibility = #public) to t : UML!Property ( visibility <- #private ), getter : UML!Operation ( namespace <- s.namespace, -- ! see later name <- 'get' + s.name.firstToUpper, ownedParameter <- getterReturnParam ), getterReturnParam : UML!Parameter ( name <- 'return', direction <- #return, type <- s.type ) } … 83 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 84. ATL 2006 Refining Mode – Implementation Overview • Computing changes  No change to the source model during rule execution, which happens as with a read-only source model  All changes are stored in a RefiningTrace model • Applying changes  After the execution of all rules • The trace:  may be serialized  could be serialized and not applied (e.g., to use a different application engine) 84 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 85. Public2Private plus Accessors – Changeability Issue rule Property { from s : UML!Property ( s.visibility = #public) to t : UML!Property ( visibility <- #private ), getter : UML!Operation ( namespace <- s.namespace, name <- 'get' + s.name.firstToUpper, ownedParameter <- getterReturnParam ), getterReturnParam : UML!Parameter ( name <- 'return', direction <- #return, type <- s.type ) } … 85 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 86. Public2Private plus Accessors – Introducing Reverse Bindings rule Property { from s : UML!Property ( s.visibility = #public) to t : UML!Property ( visibility <- #private ), getter : UML!Operation -> (s.namespace.ownedOperation) ( name <- 'get' + s.name.firstToUpper, ownedParameter <- getterReturnParam ), getterReturnParam : UML!Parameter ( name <- 'return', direction <- #return, type <- s.type ) } … 86 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 87. Launching ATL 2006 Refining Transformations • Adding inout models to the ATL Ant Task <atl.launch path="${base.path}/Public2Private.atl"> <inoutModel name="IN" model="source"/> <outModel name="refiningTrace" metamodel="RefiningTrace" model="refiningTrace"/> </atl.launch> • The user still sees different source and target models, but there are effectively the same • There are two other ways to launch a refining transformation:  Using the launch configuration (see next slide)  Programmatically (e.g., from Eclipse plugins as shown in next exercise) 87 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 88. ATL 2006 Refining Launch Configuration 88 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 89. Model Enrichment • Problem  Adding information from model mB into model mA in order to obtain enriched model mA’ • Approach  Write a transformation refining mA and taking mB as additional source model create mA’ : MMA refining mA : MMA, mB : MMB; • Example:  Annotating EDataTypes from an Ecore metamodel with instanceClassNames module ApplyAnnotations2Ecore; create OUT : Ecore refining IN : Ecore, annotations : Annotation; 89 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 90. Model Enrichment Example -- @atlcompiler atlworkspace -- @nsURI Ecore=http://www.eclipse.org/emf/2002/Ecore module ApplyAnnotations2Ecore; create OUT : Ecore refining IN : Ecore, annotations : Annotation; rule DataTypeAnnotations { from s : Ecore!EDataType to t : Ecore!EDataType ( instanceClassName <- let a : String = s.getAnnotation('instanceClassName') in if a.oclIsUndefined() then s.instanceClassName else a endif ) } -- getAnnotation helper not shown here -- […] 90 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 91. Agenda • Introduction • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 91 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 92. Second exercise: Model Refactoring • Intent  Provide in-place refactoring actions on models  Big models support  Reversible actions • Realization: a refactoring pop-up menu  Based on ATL refining mode  Available on UML2 models (both with the tree editor and UML2Tools)  Set public fields to private  Optionally adds getters and setters Use-case: privatization of public attributes 92 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 93. Second exercise: Model Refactoring • Example: refactoring on UML2Tools 93 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 94. Agenda • Introduction • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture  Overview  The new virtual machine: EMF-VM • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 94 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 95. ATL main plugins organization Eclipse ui integration Parser and Compiler utilities ATL Core API ATL EMF–specific VM ATL Regular VM 95 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 96. ATL Core API • Problem  ATL initial architecture changed many times, without strict conventions  Integration of several contributions  Two Vms, two compilers • Intent  Need to reorganize ATL core to resolve maintenance and accessibility issues  Provide an unique and simple way to use ATL programmatically • Realization  A Core API which manages models loading/saving and ATL launching  Provides extensibility at several levels 96 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 97. ATL Core API 97 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 98. ATL architecture • Intermediate file format : ASM • Modular VM dedicated to M2M support  A complete specification describes the VM (http://www.eclipse.org/m2m/atl/doc/)  Can be implemented on different platforms (Java, .Net) 98 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 99. ATL execution process • 2 steps  Compilation  Execution 99 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 100. ATL Virtual Machine • ATL core engine • Byte code interpreter (ASM)  Granular model management instruction  Uses OCL/ATL type hierarchy  Uses an abstract model handler layer • ATL VM defined by a concrete specification  Allows other language implementation • ASM code ... <operation name="122"> <context type="8"/> <parameters> </parameters> <code> <push arg="77"/> <push arg="25"/> <findme/> <push arg="23"/> ... 100 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 101. EMF-VM • A new ATL Virtual Machine is now available  Increased performance  EMF-only (no wrapping of EObjects) • At this time...  Some missing features (decreasing in number quickly): •UML profile support •Debugger interactions • Non-regression evaluated with a new test plugin 101 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 102. Non-regression tests • Non-regression engine uses EMF Compare to check output models conformance • Non-regression tests also allows to check  ATL Regular VM  ATL Compiler  ATL Parser • Provides a way for users to safely work on base components: bug corrections, new features 102 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 103. Non regression wiki page 103 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 104. EMF-VM Benchmarks 104 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 105. Agenda • Introduction • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 105 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 106. Third Exercise: A DSL Compiler for SWTBot Intent  Provide a simpler syntax for SWTBot (i.e., a Domain-Specific Language or DSL)  Generate Java code from simpler syntax Prerequisites  SWTBot DSL implementation (metamodel, syntax)  SimpleJava metamodel (only what is necessary for generation of SWTBot code) Realization  An ATL transformation from SWTBot to SimpleJava 106 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 107. Third Exercise: A DSL Compiler for SWTBot 107 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 108. Agenda • Introduction • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 108 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 109. ATL Industrialization process idea Labo experimentation industrialization Users PME validation commercialization partnership 109 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 110. Roadmap • Roadmap overview:  Industrialization  EMF-VM improvements  Stabilization  Internationalization  Improve Eclipse integration  New features  Packaging  Incremental transformation support • Means:  Existing features amelioration (IDE)  Complex features research (incremental) 110 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 111. ATL Releng module 111 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 112. Done • API refactoring  Correction of current issues  Provide a “clean” Java access to ATL for developers • ATL ant tasks • Documentation  Merging wiki / pdf  doc plugin synchronization • Many bugs corrections & feature improvements  Loading an UML2 profile from a plugin  Stable EMF ResourceSet management strategy • Examples: public2private  Provide launch configuration, ant file and java popup samples 112 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 113. What’s next? • IDE improvements  Content assist  Syntax colors  File wizard  Launch configurations  Integration of a CS contribution: ATL profiler • Debugger  Reimplemented for at least EMFVM • Documentation improvement 113 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 114. Agenda • Introduction • ATL Overview • First exercise: Model Visualization • Advanced Usage of ATL • Second exercise: Model Refactoring • Architecture • Third exercise: A DSL Compiler for SWTBot • ATL Industrialization • Discussions 114 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 115. Discussion Topics • About ATL  ATL versions (2004 vs. 2006), notably refining mode  Best Practices  Model Transformation Virtual Machines  ATL vs. QVT • Around ATL  M2M vs. M2T  Where do models come from?  Modeling platforms – AmmA  Domain-Specific Languages and Modeling  You can vote for the topics you are most interested in (2 or 3)  You may suggest additional topics 115 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 116. Legal Notices • Java and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both • Other company, product, or service names may be trademarks or service marks of others 116 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0
  • 117. END • Questions or Comments? 117 Model Refactoring and other Advanced ATL Techniques | © 2009 by INRIA, Obeo; made available under the EPL v1.0