Solving the TTC 2011 Model Migration Case with Edapt

This paper gives an overview of the Edapt solution to the GMF model migration case of the Transformation Tool Contest 2011.

💡 Research Summary

The paper presents a complete solution to the GMF model migration case of the Transformation Tool Contest 2011 using the Eclipse‑based tool Edapt. Edapt is designed to manage coupled evolution of metamodels and their instances by recording a history of “coupled operations”. A coupled operation bundles a metamodel change together with the corresponding model migration, allowing the two to be specified as a single atomic step. The tool distinguishes between reusable coupled operations – a library of more than sixty generic operators that can be parameterised and applied to many different metamodels – and custom coupled operations, which are hand‑written in Java when a transformation is too specific for reuse.

The authors first reconstructed the evolution of the two GMF metamodels (GMF Graph and GMF Map) from version 1.0 to 2.1. They used EMF Compare to generate a diff model between each consecutive pair of versions. For each diff, they selected the most appropriate reusable operation from Edapt’s catalog. Table 1 (GMF Graph) and Table 2 (GMF Map) list the operations and their frequencies; the majority of changes are covered by generic operations such as Add Super Type, Make Class Abstract when Interface, Create Attribute, Delete Feature, etc. This demonstrates that Edapt’s reusable operators are expressive enough to capture most real‑world metamodel evolution steps.

Only two transformation steps required custom code. The first custom migration initializes the newly mandatory reference FigureAccessor.typedFigure. The Java class GMFGraphTypedFigureCustomMigration iterates over all FigureAccessor instances, creates a default CustomFigure object when the reference is missing, and assigns a default qualified class name. The second custom migration decouples FigureHandle.referencingElements from the figure hierarchy, turning them into reusable FigureDescriptor and ChildAccess objects. The corresponding class GMFGraphFigureDescriptorCustomMigration performs a multi‑stage process: it first caches the relevant EReference, then for each FigureHandle it removes the old references, determines the top‑level figure, creates or reuses a descriptor, and finally creates child access objects where needed. The implementation consists of 90 lines of Java code, illustrating that Edapt’s API (instances of Model, Metamodel, Instance, etc.) provides sufficient low‑level operations to express complex migrations.

Edapt also supports multi‑file models. During migration, referenced files are loaded on demand, and users can explicitly declare a set of files to be migrated together. When a metamodel depends on another metamodel, the dependent metamodel must be available as an Eclipse plug‑in; the authors ensured this by running the migration inside an Eclipse workbench with the required plug‑ins installed.

To verify correctness, the authors applied the generated migration to the official TTC test models and compared the results with the expected models using EMF Compare. They ignored differences in reference ordering, which is irrelevant for the GMF models. All test cases passed, confirming that the combination of reusable and custom operations yields a correct migration.

The paper evaluates the solution along four dimensions:

• Expressiveness – The reusable operations cover the bulk of the evolution; the two custom operations, written in Java, are sufficient for the remaining complex steps.
• Conciseness – The migration script is compact: only two custom operations (21 and 90 lines) are needed, the rest being declarative reusable operations.
• Maintainability – The history model is modular, with each coupled operation recorded separately. It can be replayed, undone, or extended, and intermediate metamodel versions can be reconstructed from the history.
• Potential Improvements – The authors suggest that a domain‑specific language (DSL) for custom migrations could further reduce boilerplate compared to the current Java API.

In conclusion, the authors demonstrate that Edapt provides a practical, scalable approach to model migration in the presence of evolving metamodels. By leveraging a rich library of reusable coupled operations and a straightforward Java API for custom steps, Edapt achieves a balance between automation and flexibility, making it suitable for real‑world model‑driven engineering projects where metamodels evolve over time.