History

You are here:

1996-1999: First infrastructure, meta-model

Moose was born in the context of FAMOOS, a European project that took place between Sept. 1996-Sept. 1999. FAMOOS focussed on methods and tools to analyse and detect design problems in object-oriented legacy systems, and to migrate these systems towards more flexible architectures.

The main results of FAMOOS are summarized in the FAMOOS Handbook and in the “Object-Oriented Reengineering Patterns” book.

In the beginning of the FAMOOS project Moose was merely the implementation of a language independent meta-model known as FAMIX.

The parsing of C/C++ code was done through Sniff+, and the produced models were imported via the CDIF standard. Initially, Moose provided for a hard-coded importer and served as basis for simple visualization and program fact extractor (1997). Then it started to be used to compute metrics.

Later on, as the meta-model evolved, it became apparent that the import/export service should be orthogonal to the meta-model and most important that the environment should support meta-model extension. As a consequence, a first, extremely simple meta-meta-model was implemented, which, at the time, could represent entities and relationships (1998).

1999-2003: Interchange formats, visualizations

With the introduction of the XMI standard, a first MOF meta-meta-model was implemented and CDIF meta-models were transformed into MOF meta-models for the XMI model generation. However, MOF was not used as the underlying Moose meta-meta-model.

In parallel, the visualization development led to the extension of the set of metrics computed. At the time, CodeCrawler was the flagship application of Moose, and for a significant period CodeCrawler influenced the architecture of Moose (1999). For example, the metrics had to be computed for all entities before the views could be generated.

The interest in researching the evolution of systems led to the implementation of the meta-model repository. As such, the first application was the Evolution Matrix (2001). Later on, more research was invested in understanding the evolution of systems, resulting in the development of Van (2002).

Because the evolution analysis requires large amounts of data to be manipulated, it was not feasible anymore to manipulate all the model information all the time. Also, the computation of the metrics beforehand for all entities in the model was another bottleneck. As a consequence, several services were implemented: partial loading of the models, lazy computation of the properties, and caching of results.

It became apparent that the meta-descriptions are a powerful way of separating the data representation (i.e., the meta-model) from the different techniques to manipulate this data. We consequently started to implement a MOF-like meta-meta-model (2002) and replaced the original one. It offers an architecture similar to that of the Eclipse Modeling Framwork (EMF).

2003-2007: Generic UI, custom interchange format, scriptable visualizations

As an application of the meta-description, the development of a generic GUI was started to provide basic services such as navigation, querying, and introspection (2003). An important role in the caching mechanism and in the querying is played by the notion of a group as a first-class entity: every query or selection in Moose yields a group, and any group can be manipulated in the Browser (2003).

Almost all Tools currently in use, have been built during this period. To ease tool development, a plug-in mechanism was needed. Thus, based on meta-description, each tool can register itself to the menu attached to each entity in the meta-model. This simple mechanism allows these tools to complement each other without imposing a hard-coded dependency between them.

The combination of menus and groups meant that complex analyses could be broken down into multiple steps, each of which may make use of a different tool. Combining and composing tools thereby becomes natural and transparent.

In 2006, Meta was created as a self-described implementation of EMOF (Essential Meta Object Facility) and it replaced the meta-meta-model of Moose. Together with Meta, the new MSE was created. Because Meta is self described, Moose is now able to load both externals models and meta-models using the same mechanism.

To provide support for fast prototyping of interactive visual tools, Mondrian was built. Mondrian uses Smalltalk as an underlying scripting language and adds support for graph based visualizations. Mondrian received 2nd prize at the ESUG 2006 Innovation Awards.

In 2007, a new engine, called EyeSee, grew up around Moose to allow for scripting Excel-like charts. EyeSee received 2nd prize at the ESUG 2007 Innovation Awards.

2008-2010: FAMIX 3.0, scriptable browsers and the move to Pharo

In 2008, Meta was replaced by Fame that implements a new meta-meta-model (FM3) that is simpler and more flexible than EMOF. The effort for building Fame is correlated with the development of FAMIX 3.0, a family of meta-models for software analysis.

Starting with the end of 2008, a large effort was started to move Moose from VisualWorks to Pharo, an open source Smalltalk. The first alpha version under Pharo was release in August 2009.

During this time Glamour was developed, an engine for scripting interactive browsers. Glamour received the 3rd prize at the ESUG 2009 Innovation Awards.

Petit Parser was added to the Moose Suite. PetitParser is a novel engine for creating dedicated parsers.