Misha is a debug-oriented research I.D.E. developed at the Technical University of Crete and
GPLv3 license that introduces among
other things: syntax-aware navigation, data-displaying and editing, reverse
execution, debugging scripting and inter-language evaluation through the
integration of its source-level debugger (gdb) with a full-fledged source
parser, data visualisation tools and other free software technologies.
In that sense Misha features what is called a high-level debugging system where the amount of available debugging information is expanded
through direct access to a semantically annotated parse tree, thus creating new ways for programmers to form their development cycle. If you want to
contact the author, for feedback and praise ;) send us an e-mail here.
Syntax Aware Navigation
As we you can see in the adjastent figure individual group statements, if, while and other
syntax structures are blocked together in Misha to form logical units of execution
that can accordingly be traversed.
For example loop statements (either
while or for loops) can be traversed as whole structures, iteration by
iteration or even in user-defined evolution steps, both in forward and backward execution modes. This traversal can be
either breadth-first in a bottom-up fashion inside the syntax tree, or depht-first
while the debugger is automatically advancing through source code in human-mode.
Data-Displaying and Editing
Data Displaying and editing
Here we can see an example of data-displaying in Misha, where the iteration inside a bst tree is depicted. The
programmer is monitoring in execution time the evolution of data on
the graph and through menus and even edits values as he goes along.
The graph depth is variable and can be arbiteraly defined by the user, as well as the zoom factor for the entire data display through scrolling of the mouse wheel. The data display context menu, provides several
facilities, including showing/hiding address values and evaluation of
user-defined expressions among other things.
Stepping backwards in time while debugging is
a valuable tool that could not be absent from our research effort. It
is also a community proposal, listed in the high priority project
list of the Free Software Foundation.
As we can see upon invocation of the record facility (gdb) by the user, the ability
to step backwards in time is enabled. In Misha we 've also enabled syntax
navigation in this mode, providing total control over
In this figure, the programmer
steps backwards from an if statement to review the invokation of a
bst search function.
Through a general purpose extention language (Python) the developer is able to control to control our parser, the visualisation
subsystem, the symbolic debugger as well as the "high-level" debugging facilities.
Python bindings for the gdb/mi are also provided giving a different architectural approach to the recent python scripting capabilities of gdb.
Misha's versatile debugging console interaction,
things like syntax error reporting, data displaying in
graphs, full scripting of the environment’s API and direct python to c
calls for the project being developed.
This is where the main interaction
with our general purpose debugging extention language takes place.
The programmer can monitor and control literally every aspect of the
environment from this very console and intrepreter.
Directly and seamlessly call each project’s C functions from
within python. This feature besides being usefull for unit testing
and code benchmarking purposes, encourages a multi-language
approach in software enginnering which is a critical aspect of our
future intentions for Misha.
Moreover python scripts have access to the extentibility API of the environment,
a feature that when combined with our multi-language
development approach can provide on-line extentibility of our IDE both
in c and in python during normal program execution.
On the side you can see a python matplotlib extention script that graphs some output of a c project.
Presenting the programmer with a lot of data
and options all at the same time, is not always the best thing
to do, but debuggers and IDEs from the very nature tend to
demand their share of the desktop.
In order to address these
issues we developed new graphic widgets for the gnome platform,
innovative input facilities that support speech and bluetooth devices,
a web-documentation system with a dedicated crawler and
a comprehensive project management system based on gnu-make
that automates the search for library and source dependencies