After several months of (more or less) active development we are proud to introduce our latest and greatest release of the Debug Visualisation Eclipse plug-in.
The changes are three-folds in this release: first, a view model is defined for the visualisation. This one is only interesting for us, developers, as it enables us to store calculated data together with the referenced variable or value, making it easier to produce new features in later releases.
The other changes are more visible: we integrated our approach with the debug platform: it is possible to add variables to the visualisation by using the context menu of the Variables View. For similar reasons, our custom filter implementation was replaced with the platform-defined logical structures. This means, more specific filters are available, and it is possible (at least for Java) for the user to define more in the corresponding Eclipse preferences page (Java/Debug/Logical Structures).
These stuctures provide a way to removed some (possibly) irrelevant variables from the visualisation, as it is possible to define on a per-type basis the relevant structure (and it is also possible to define multiple structures for the same type, allowing the user to choose between them).
These structures can be selected from the context menu of the values in the Visualisation view. Such a possible selection is depicted on the following screenshot:
Warning: the logical structure selection is (and possibly will) not synchronized with the variables view.
Finally, some internal changes were made to ensure, the plug-in is easier to use, such as the ability to define custom orderings for some layouts.
For a list of all fixed issues visit our issue tracker.
The new release can be downloaded from our update site right now (http://eclipse.cubussapiens.hu), and hopefully shortly also from the Eclipse Marketplace.
Update: Detailed project information is available from our Google Code project page.
Update2: The new release is available (and installable) from the Eclipse Marketplace.
This reminds me a bit of the Data Display Debugger (http://www.gnu.org/software/ddd/). It would be very cool if you had the visualization show the fields inside the boxes.
I assume you’re using Zest? If you wanted to get more detailed in the boxes you might have to go with a more raw GEF though…
Yes, we use Zest. Luckily Zest supports since version 1.1 (Galileo release train) some kind of nested nodes and also custom nodes (drawn in Draw2D).
On the other hand it is harder to decide how to include the elements inside the node. An idea was to include all textual information as text information, but in some cases (typically EMF model instances) it was unusable: see the screenshots of the issue http://code.google.com/p/debugvisualisation/issues/detail?id=8
On the other hand we plan to address this issue somehow, but the concrete way is hard to see – as of now.
Thanks for the DDD link, I will look at it in more details.
A link to your project would be helpful. I assume this is it?
http://code.google.com/p/debugvisualisation/
Bryan: yes, it is. I also updated the text of the article to include it. Thanks for the feedback.
As a CS student, I’ve been looking around the web for a simple way to visualize data structures. Pretty much display my variables in graph form because clicking around in the Variables view is not fun :X
Your project seems to be getting there. There’s a similar project that does this too called Fujaba, but it’s a bit more complicated: http://www2.cs.uni-paderborn.de/cs/ag-schaefer/Lehre/PG/FUJABA/
Do you think your tool is a good way for students to debug their data structures with?
If not, well just ignore everything below (they’re just “suggestions” reworked as questions)
————
Right now I’m programming a heap and I’m using your tool to make sure that all the nodes are ordered correctly, so how successful have you been (so far) in displaying instance variables within each node? Also I’m implementing graphs using adjacency lists, these ones are a bit more difficult to view since the primitive arrays are displayed as nodes. Am I ever going to be able to view primitive arrays as arrays or am I gonna have to use ArrayLists in order for them to be properly displayed in the visualization?
Update on Fujaba, it’s sub-project DOBS is the closest thing to your project: http://www.se.eecs.uni-kassel.de/~fujabawiki/index.php/EDOBS
but it crashes Eclipse….oh well.
@ilovecomputers As far as I know, FUJABA is more related to model transformations than debugging. It provides means to describe the transformation between models (or model states), and the DOBS subproject tries to visualize model states.
We have achieved similar results in the VIATRA2 model transformation project, where we try to visualize the model space using a similar Zest-based visualization.
About usefulness: I hope, the tool is useful for software debugging – it is a new tool right next to variables display, the various break- and watchpoints, etc. etc. etc. For getting an overview of data structures, I find it sometimes useful – e.g. once I had a huge array, and an element right next to it, and wanted to know, which element is it in the array (by index). Instead of manually traversing the array, I opened it using the visualization, and then clicked the outstanding item in the variables view, and I got the item selected in the visualisation, together with its index.
About your questions (suggestions): can you please give some details, how to understand your question. The tool _is_ used to visualize instance variables (not class structure, etc.). And I’m not sure, how you would like to display array variables instead of the current one. The problem comes possibly from the fact, that I’m too into my project, and do not see others needs as good.