# Moose (analysis)

Moose is a free and open source platform for software and data analysis built in Pharo.
Moose offers multiple services ranging from importing and parsing data, to modeling, to measuring, querying, mining, and to building interactive and visual analysis tools. Moose was born in a research context, and it is currently supported by several research groups throughout the world. It is increasingly being adopted in industry.

## Key Features

The philosophy of Moose is to enable the analyst to produce new dedicated analysis tools, and to customize the flow of analysis. While Moose is mainly used in software analysis, it is built to work for any data.
To achieve this it offers multiple mechanisms and frameworks:
* Importing and meta-meta-modeling is achieved through a generic meta-described engine. Any meta-model is described in terms of a self-described meta-meta-model, and based on this description, the import/export is provided through the MSE file format. Through this file format, Moose can exchange data with external tools.
* For parsing, Moose provides a novel framework that makes use of several parsing technologies (like parsing expression grammar) and that provides a fluent interface for easy construction.
* Software analysis is specifically supported through the FAMIX family of meta-models. The core of FAMIX is a language independent meta-model that is similar to UML but it is focused on analysis. Furthermore, it provides rich interface for querying models.
* Visualization is supported through two different engines: one for expressing graph visualizations, and one for expressing charts. They both provide a fluent interface for easy construction.
* Browsing is an important principle in Moose, and it is supported in multiple ways as well. A generic interface enables the analyst to browse any model. To be able to specify specific browsers, Moose offers a generic engine that eases the specification through a specific fluent interface.

## History
### 1996-1999: First infrastructure, meta-model

Moose was born at the University of Bern 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 Meta-Object Facility 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. Consequently, the team 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 Framework (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).
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 file format was created. Because Meta is self described, Moose is now able to load both externals models and meta-models using the same mechanism. In the same time, XMI and CDIF support was dropped.
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-2011: 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 released 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.
PetitParser was added to the Moose Suite. PetitParser is a novel engine for creating dedicated parsers.