To provide support for answering the questions that integrators raise during the integration of changes, we need to model the necessary information presented in the previous section.
leveraged by various software engineering tools is not new. Along the representations of object- oriented programs, several approaches exist that model changes and multiple versions of a system. A good overview of the early research in this area can be found in the book chapter by D’Ambros et al.[D’Ambros 2008].
In the following, we introduce several meta-models that support source code, history and change representation or reason about the evolution of a software system.
FAMIX. FAMIX [Ducasse 2000, Tichelaar 2000] is a family of meta-models for representing the source code of object-oriented systems. FAMIX offers a language-independent, first-class repre- sentation of object-oriented, class-based languages that has been used by a wide range of software engineering tools such as the Moose5platform for software and data analysis.
EMF – ECore and GenModel. ECore6is a source code meta-model for describing Java models and the run-time support for the models within the Eclipse Modeling Framework (EMF). EMF instantiates models that conform to an ECore meta-model by code generation. The Java classes are generated from an ECore meta-model specification. This process is performed in two steps: (1) the ECore meta- model is transformed into a GenModel7 model that can contain additional implementation-specific information. (2) a model-to-text (M2T) transformation consumes the GenModel in order to generate the functional Java code.
Hismo. Gîrba [Gîrba 2005a,Gîrba 2006] proposed Hismo, a history-based approach that extends the FAMIX source core meta-model to provide facilities for representing and reasoning over the history of a software system. It represents multiple versions of a system within a single history model. A version is a snapshot of the system, a complete FAMIX representation of that version along with information that relates source code entities over various versions.
SpyWare. Robbes and Lanza [Robbes 2007, Robbes 2008b] developed the SpyWare change-aware development toolset. It tracks and reasons about the changes a developer makes to a program within the integrated development environment (IDE). SpyWare provides a fine-grained model that repre- sents changes as first-class entities. With this change-based evolution model, systems are represented as evolving abstract syntax trees (ASTs), composed of domain-entities (packages, classes, methods, variables and statements) specific for the base language (Smalltalk and Java). Each entity (AST node) has a change history containing all the changes representing one particular state of the program during the system’s evolution.
ChEOPS. Ebraert [Ebraert 2007] presented ChEOPS, a proof-of-concept implementation of change-based feature-oriented programming (FOP). The underlying meta-model is an extension of the FAMIX source core meta-model that represents fine-grained first-class change objects based on de- velopment actions. ChEOPS shares the objectives and advantages with SpyWare. However, ChEOPS does not represent a program as evolving abstract syntax trees; instead it allows developers to define
5 Moose:http://www.moosetechnology.org 6ECore:http://download.eclipse.org/modeling/emf/emf/javadoc/2.8.0/org/eclipse/emf/ecore/package-summary.html 7 GenModel: http://download.eclipse.org/modeling/emf/emf/javadoc/2.8.0/org/eclipse/emf/codegen/ecore/ genmodel/package-summary.html
3.5. State-of-the-Art 43
their own domain-specific and high-level changes, apply those changes, undo changes and verify the preconditions of the changes to ensure the application consistency.
Syde. Hattori and Lanza [Hattori 2009a,Hattori 2009b,Hattori 2010] proposed Syde, a client-server toolset for synchronous development of Java systems. Syde extends Spyware’s change-based evolu- tion model to deal with changes made by multiple developers working in parallel. The evolution of a system is modeled as a set of sequences of changes, where each sequence is produced by one developer. On the client-side, Syde traces two types of change operations (atomic changes and re- name/move refactorings). On the server-side, it keeps one AST per developer, which reflects the state of the system at a developer’s workspace.
Orion. Laval [Laval 2009, Laval 2011] developed Orion, an interactive prototyping tool for soft- ware reengineering that allows developers to simulate changes and compare their impact on multiple versions of software source code models. Orion’s meta-model is an extension of the FAMIX source code meta-model designed to optimize memory usage of multiple versions for large models. Orion’s meta-model supports the sharing of entities between versions. To save memory space and decrease creation time, program entities which do not change are shared between different versions of the model.
Other approaches
Ebraert and Molderez [Ebraert 2010] extended the change model underlying ChEOPS [Ebraert 2007] with the notion of intensional changes – descriptive changes that can evaluate to an extension of changes – to support the modularization of crosscutting features. Meyers et al. [Meyers 2010] use that work on intensional changes to avoid co-evolution in the domain of change-based feature-oriented programming. Ebraert et al. [Ebraert 2011] makes use of the ChEOPS’ meta-model to present a bottom-up approach for generating Feature-Oriented Domain Analysis (FODA) diagrams from the changes to the source code, thus bridging the gap between feature-oriented design and implementa- tion.
Orthogonally to the mentioned modeling approaches, there exist a number of language represen- tation toolkits such as CDT8(Eclipse’s C/C++ Development Tooling) or Necula et al.’s [Necula 2002] approach CIL, a high-level source code representation along with a set of tools that permit easy anal- ysis and source-to-source transformation of C programs. These approaches do not address software history.
Discussion
The use of first-class change objects has been applied in a variety of fields. Syde uses first-class changes to increase awareness of changes made by other developers in multi-developer projects. Spy- Ware has shown that the fine-grained changes contain a lot more information about the evolution of a software system than when using snapshot-based information. ChEOPS has been used in the context of FOP combining changes into features [Ebraert 2008]. Orion has been used to represent the future by simulating scenarios of multiple versions of a system in the context of software reengineering.
While existing meta-models provide a rich medium to model source code or changes, none of the existing approaches provide a complete unified representation of a system’s source code, history and individual changes, and reason over the history and changes in the context of branching and merging. Furthermore, the Hismo meta-model does not scale for large histories, and it is unclear how existing models for representing changes scale with respect to large numbers of changes.