Moose (analysis)

Last updated
Moose
Developer(s) The Moose Team
Stable release
8.0.1 / February 5, 2021 (2021-02-05)
Written in Smalltalk
Operating system Cross-platform
Type Data analysis
License BSD License
Website modularmoose.org

Moose is a free and open source platform for software and data analysis built in Pharo.

Contents

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, [1] and it is currently supported by several research groups throughout the world. It is increasingly being adopted in industry[ citation needed ].

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:

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 [6] 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.

Related Research Articles

<span class="mw-page-title-main">Smalltalk</span> Object-oriented programming language released first in 1972

Smalltalk is a purely object oriented programming language (OOP) that was originally created in the 1970s for educational use, specifically for constructionist learning, but later found use in business. It was created at Xerox PARC by Learning Research Group (LRG) scientists, including Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Diana Merry, and Scott Wallace.

<span class="mw-page-title-main">Squeak</span> Object-oriented programming language

Squeak is an object-oriented, class-based, and reflective programming language. It was derived from Smalltalk-80 by a group that included some of Smalltalk-80's original developers, initially at Apple Computer, then at Walt Disney Imagineering, where it was intended for use in internal Disney projects. The group would later go on to be supported by HP Labs, SAP, and most recently, Y Combinator.

The XML Metadata Interchange (XMI) is an Object Management Group (OMG) standard for exchanging metadata information via Extensible Markup Language (XML).

<span class="mw-page-title-main">Meta-Object Facility</span> Standard of Object Management Group

The Meta-Object Facility (MOF) is an Object Management Group (OMG) standard for model-driven engineering. Its purpose is to provide a type system for entities in the CORBA architecture and a set of interfaces through which those types can be created and manipulated. MOF may be used for domain-driven software design and object-oriented modelling.

The Object Constraint Language (OCL) is a declarative language describing rules applying to Unified Modeling Language (UML) models developed at IBM and is now part of the UML standard. Initially, OCL was merely a formal specification language extension for UML. OCL may now be used with any Meta-Object Facility (MOF) Object Management Group (OMG) meta-model, including UML. The Object Constraint Language is a precise text language that provides constraint and object query expressions on any MOF model or meta-model that cannot otherwise be expressed by diagrammatic notation. OCL is a key component of the new OMG standard recommendation for transforming models, the Queries/Views/Transformations (QVT) specification.

Windows Management Instrumentation (WMI) consists of a set of extensions to the Windows Driver Model that provides an operating system interface through which instrumented components provide information and notification. WMI is Microsoft's implementation of the Web-Based Enterprise Management (WBEM) and Common Information Model (CIM) standards from the Distributed Management Task Force (DMTF).

Given that metadata is a set of descriptive, structural and administrative data about a group of computer data, Java Metadata Interface is a platform-neutral specification that defines the creation, storage, access, lookup and exchange of metadata in the Java programming language.

The common warehouse metamodel (CWM) defines a specification for modeling metadata for relational, non-relational, multi-dimensional, and most other objects found in a data warehousing environment. The specification is released and owned by the Object Management Group, which also claims a trademark in the use of "CWM".

GXL is designed to be a standard exchange format for graphs. GXL is an extensible markup language (XML) sublanguage and the syntax is given by an XML document type definition (DTD). This exchange format offers an adaptable and flexible means to support interoperability between graph-based tools.

<span class="mw-page-title-main">Metamodeling</span> Concept of software engineering

A metamodel is a model of a model, and metamodeling is the process of generating such metamodels. Thus metamodeling or meta-modeling is the analysis, construction, and development of the frames, rules, constraints, models, and theories applicable and useful for modeling a predefined class of problems. As its name implies, this concept applies the notions of meta- and modeling in software engineering and systems engineering. Metamodels are of many types and have diverse applications.

<span class="mw-page-title-main">Class browser</span> Feature of coding platforms

A class browser is a feature of an integrated development environment (IDE) that allows the programmer to browse, navigate, or visualize the structure of object-oriented programming code.

Graph Modeling Language (GML) is a hierarchical ASCII-based file format for describing graphs. It has been also named Graph Meta Language.

In computer programming, a trait is a concept used in programming languages which represents a set of methods that can be used to extend the functionality of a class.

Application discovery and understanding (ADU) is the process of automatically analyzing artifacts of a software application and determining metadata structures associated with the application in the form of lists of data elements and business rules. The relationships discovered between this application and a central metadata registry is then stored in the metadata registry itself.

<span class="mw-page-title-main">Seaside (software)</span> Smalltalk web framework

Seaside, an acronym that stands for “Squeak Enterprise Aubergines Server with Integrated Development Environment,” is computer software, a web framework to develop web applications in the programming language Smalltalk. It is distributed as free and open-source software under an MIT License.

The DMS Software Reengineering Toolkit is a proprietary set of program transformation tools available for automating custom source program analysis, modification, translation or generation of software systems for arbitrary mixtures of source languages for large scale software systems. DMS was originally motivated by a theory for maintaining designs of software called Design Maintenance Systems. DMS and "Design Maintenance System" are registered trademarks of Semantic Designs.

<span class="mw-page-title-main">Pharo</span>

Pharo is a cross-platform implementation of the classic Smalltalk-80 programming language and runtime system. It is based on the OpenSmalltalk virtual machine (VM) named Cog, which evaluates a dynamic, reflective, and object-oriented programming language with a syntax closely resembling Smalltalk-80. It is free and open-source software, released under a mix of MIT, and Apache 2 licenses.

<span class="mw-page-title-main">Oscar Nierstrasz</span> Swiss-Canadian software engineer and programmer

Oscar Marius Nierstrasz is a professor at the Computer Science Institute (IAM) at the University of Berne, and a specialist in software engineering and programming languages. He is active in the field of programming languages and mechanisms to support the flexible composition of high-level, component-based abstractions, tools and environments to support the understanding, analysis and transformation of software systems to more flexible, component-based designs, secure software engineering, and requirement engineering to support stakeholders and developers to have moldable and clear requirements. He has led the Software Composition Group at the University of Berne since 1994 to date.

<span class="mw-page-title-main">Amber Smalltalk</span>

Amber Smalltalk, formerly named Jtalk, is an implementation of the programming language Smalltalk-80, that runs on the JavaScript runtime of a web browser. It is designed to enable client-side development using Smalltalk. The programming environment in Amber is named Helios.

References

  1. ↑ Oscar Nierstrasz, Stéphane Ducasse, and Tudor Gîrba. The Story of Moose: an Agile Reengineering Environment. In Proceedings of the European Software Engineering Conference (ESEC/FSE'05), p. 1—10, ACM Press, New York NY, 2005. Invited paper.
  2. ↑ Stéphane Ducasse, Tudor Gîrba, Adrian Kuhn, and Lukas Renggli. Meta-Environment and Executable Meta-Language using Smalltalk: an Experience Report. In Journal of Software and Systems Modeling (SOSYM) 8(1) p. 5—19, February 2009.
  3. ↑ Adrian Kuhn and Toon Verwaest. FAME, A Polyglot Library for Metamodeling at Runtime. In Workshop on Models at Runtime, p. 57—66, 2008
  4. ↑ Lukas Renggli, Stéphane Ducasse, Tudor Gîrba, and Oscar Nierstrasz. Practical Dynamic Grammars for Dynamic Languages. In 4th Workshop on Dynamic Languages and Applications (DYLA 2010), Malaga, Spain, June 2010
  5. ↑ Michael Meyer, Tudor Gîrba, and Mircea Lungu. Mondrian: An Agile Visualization Framework. In ACM Symposium on Software Visualization (SoftVis'06), p. 135—144, ACM Press, New York, NY, USA, 2006.
  6. ↑ Serge Demeyer, Stéphane Ducasse, and Oscar Nierstrasz. Object-Oriented Reengineering Patterns, Square Bracket Associates, 2008. URL
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.