Moose tool

Moose is a language-independent environment for reverseand
re-engineering complex software systems. Moose provides
a set of services including a common meta-model, metrics
evaluation and visualization, a model repository, and
generic GUI support for querying, browsing and grouping.
The development effort invested in Moose has paid off in
precisely those research activities that benefit from applying
a combination of complementary techniques. We describe
how Moose has evolved over the years, we draw a number
of lessons learned from our experience, and we outline the
present and future of Moose.

1. INTRODUCTION
Software systems need to evolve continuously if they are to
be effective [41]. As systems evolve, their structure decays,
unless effort is undertaken to reengineer them [41, 44, 23,
11].
The reengineering process comprises various activities, including
model capture and analysis (i.e., reverse engineering),
assessment of problems to be repaired, and migration
from the legacy software towards the reengineered system.
Although in practice this is an ongoing and iterative process,
we can idealize it (see Figure 1) as a transformation through
various abstraction layers from legacy code towards a new
system [11, 13, 35].

What may not be clear from this very simplified picture is
that various kinds of documents are available to the software
reengineer. In addition to the code base, there may be documentation
(though often out of sync with the code), bug
reports, tests and test data, database schemas, and especially
the version history of the code base. Other important
sources of information include the various stakeholders (i.e.,
users, developers, maintainers, etc.), and the running system
itself. The reengineer will neither rely on a single source of
information, nor on a single technique for extracting and
analyzing that information [11].
Reengineering is a complex task, and it usually involves
several techniques. The more data we have at hand, the
more techniques we require to apply to understand this data.
These techniques range from data mining, to data presentation
and to data manipulation. Different techniques are
implemented in different tools, by different people. An infrastructure
is needed for integrating all these tools.
Moose is a reengineering environment that offers a common
infrastructure for various reverse- and re-engineering
tools [22]. At the core of Moose is a common meta-model
for representing software systems in a language-independent
way. Around this core are provided various services that
are available to the different tools. These services include
metrics evaluation and visualization, a repository for storing
multiple models, a meta-meta model for tailoring the Moose
meta-model, and a generic GUI for browsing, querying and
grouping.
Moose has been developed over nearly ten years, and has
itself been extensively reengineered during the time that it
has evolved. Initially Moose was little more than a common
meta-model for integrating various ad hoc tools. As it

became apparent that these tools would benefit immensely
from a common infrastructure, we invested in the evolution
and expansion of Moose. This expansion faced numerous
challenges, particularly that of scalability, since legacy systems
tend to be large. Without extensive reengineering,
however, Moose itself would have quickly become unwieldy
and unmanageable. Instead, we have managed to keep the
core of Moose quite small, and only extended its functionality
when there was a clear added value to be obtained.
In its latest version Moose has 217 implementation classes
and 78 test classes.
Common wisdom states that one should only invest enough
in a research prototype to achieve the research results that
one seeks. Although this tactic generally holds, it fails in
the reengineering domain where a common infrastructure
is needed to even begin to carry out certain kinds of research.
In an nutshell, the added value arises precisely when
multiple techniques can be combined to break new research
ground.
From another perspective, the research process consists
of formulating an hypothesis based on observations, and
performing an experiment to evaluate the hypothesis. The
shorter the distance between the formulation and the evaluation
of an hypothesis, the more hypotheses can be explored.
With Moose, one can reuse and extend the previous experiences
and, in this way, shorten the distance between the
original hypothesis and the result.
In this paper we attempt to draw some lessons from our
experience developing and using the Moose environment.
In Section 2 we outline the current architecture of Moose,
and we briefly recount the history of its evolution. Then, in
Section 3 we see how Moose has been used to carry out
an array of different reverse- and re-engineering research
projects. In each case, we can see that the investment in
Moose paid off precisely at the point where multiple techniques
are being combined to achieve a particular research
goal. In effect, we could greatly accelerate the research activities
because we had an infrastructure upon which we
could build, even though this infrastructure was at any point
in time rather minimal. In Section 4 we summarize some of
the lessons learned. We conclude in Section 5 with some
remarks on our ongoing research activities.

About eagle081183

Passionate, Loyal
This entry was posted in C#, Software architecture. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s