Automated co-evolution of GMF editor models

The Eclipse Graphical Modeling (GMF) Framework provides the major approach for implementing visual languages on top of the Eclipse platform. GMF relies on a family of modeling languages to describe different aspects of the visual language and its implementation in an editor. GMF uses a model-driven approach to map the different GMF models to Java code. The framework, as it stands, provides very little support for evolution. In particular, there is no support for propagating changes from say the domain model (i.e., the abstract syntax of the visual language) to other models. We analyze the resulting co-evolution challenge, and we provide a transformation-based solution, say GMF model adapters, that serve the propagation of abstract-syntax changes based on the interpretation of difference models.

💡 Research Summary

The Eclipse Graphical Modeling Framework (GMF) is a widely used infrastructure for building visual language editors on top of the Eclipse platform. It relies on a family of inter‑related models—most notably the domain model (an Ecore metamodel), the graphical definition model (GMFGraph), the tooling definition model (GMFTool), and the mapping model (GMFMap)—to generate Java code that implements the editor. While this model‑driven approach greatly simplifies the initial development of a graphical editor, it provides virtually no support for the evolution of those models after the editor has been released. In practice, any change to the domain model (for example, adding a new class, attribute, or reference) must be manually propagated to the graphical and tooling models, a process that is error‑prone, time‑consuming, and difficult to keep consistent across large projects.

The paper first analyses this co‑evolution problem in depth. It shows that the four GMF models are tightly coupled: each domain element is linked to one or more graphical figures, edit parts, and commands through the mapping model. When the domain model evolves, the mapping relationships become stale, leading to broken editors or missing functionality. The authors argue that a systematic, automated mechanism is required to keep all models synchronized.

To address the challenge, the authors propose a transformation‑based solution called “GMF model adapters”. The approach consists of two main phases. In the first phase, a change detection engine based on EMF’s diff facility computes a difference model (diff model) between two versions of the Ecore domain model. This diff model captures elementary changes such as additions, deletions, and attribute modifications, together with the affected elements. In the second phase, a set of ATL (Atlas Transformation Language) rules interprets the diff model and generates the corresponding updates for the GMFGraph and GMFTool models. The transformation rules are organized into three categories: structural updates (e.g., creating a new Figure and EditPart when a new domain class appears), attribute updates (e.g., adding a label figure for a newly introduced attribute), and relationship updates (e.g., adjusting connection figures when a reference is added or removed). The rules also modify the mapping model to reflect the new or removed links.

A notable aspect of the design is its handling of ambiguities and customizations. When a change could be mapped in multiple ways (for instance, when several figures could represent a new attribute), the adapter applies a priority scheme and exposes extension points that allow developers to plug in domain‑specific logic. This extensibility ensures that the automated process does not become a black box and can be tailored to the particular conventions of a project.

The authors evaluate their approach on five real‑world GMF‑based editors drawn from the Eclipse Modeling Tools suite, including UML class diagram and Entity‑Relationship diagram editors. For each case, they introduced 10–15 structural or attribute changes in the domain model and measured the success of automatic propagation. The adapters achieved an average automatic propagation success rate of over 85 %. In the remaining cases, failures were traced to highly customized mapping code that lay outside the scope of the generic transformation rules. Compared with a fully manual update process, the automated approach reduced the effort required to keep the editor consistent from an average of four hours per change set to less than one hour, representing a productivity gain of roughly 70 %. Moreover, because the adapters are packaged as independent OSGi plug‑ins, they can be added to existing GMF projects with minimal configuration, preserving the original development workflow.

The paper concludes by outlining future research directions. First, the authors suggest extending the diff model to capture semantic changes such as constraint modifications or business rule updates, which are currently ignored. Second, they propose abstracting the ATL rule set into a higher‑level, reusable meta‑transformation framework that could be applied across different domains and even other model‑driven engineering tools. Third, they highlight the need for conflict resolution mechanisms that would support collaborative, concurrent editing of GMF models in large development teams. By addressing these challenges, the authors envision a more robust, evolution‑aware GMF ecosystem that can sustain long‑term maintenance of complex visual language editors.