I'm looking to select an open source debugger that has a codebase that is reasonable to work with for the purpose of adding a new data visualization technique. I was thinking about working with DDD (Data Display Debugger) but wanted to become aware of other options if possible. I realize I could write a new GUI on top of something like GDB, but that seems a bit heavier than needed and perhaps less useful in the end.
Does anyone have experience changing or hacking the DDD or GDB source code? Is there another common open source debugger I should consider modifying instead?
http://en.wikipedia.org/wiki/Data_Display_Debugger
first - DDD is just a front end on gdb. If you want to offer a new way of looking at data - what new way ? there are already a pretty complete set and you may end up having to hack both gdb and the DDD front end
I want to add an integrated view in the debugger for laying out data structures with the force-directed placement algorithm. I would think that most people who have spent a good amount of time with DDD and other visual debuggers find their layout of data structures to be quite lacking.
For a simple example, consider a circular doubly linked list. To view the linked list in the DDD data display pane, one needs to click on every single node of the LL to expand the next node that is pointed to. Once one clicks 50 or so times to get the data structure displayed (size = 50 in this example), it is positioned in the data display view in a horrible layout where the user is mainly expected to drag around the boxes representing the nodes of the LL manually to get them into a position where the view is useful and makes sense.
Now take this example and consider a more complicated data structure, such as a threaded B-tree or some such. It just doesn't work out well, and more time is spent messing about with the view and/or manually printing out values than is spent actually understanding the contents of the data structure to determine what may be going wrong.
1) The user should not have to click on every node of a pointer-linked data structure to expand and view it. This should be highly automated. While there may need to be some way the user can choose which pointer fields of a structure are to be expanded to form edges in the graph/tree to be displayed, interaction should be with the data structure as a whole. The user should not need to interact with every single individual node of the data structure to get it displayed with a reasonable layout on screen.
2) The user should not need to manually place every single node of the data structure in the view manually to get things displayed in a way that makes sense. The layout should be able to be generated automatically and an intuitive layout should be created. E.g. a circular doubly linked list should show up as a circle or similar shape. A tree should look like a tree when it is expanded and displayed. For these cases, force-directed placement would work _very_ well.
well, you make a good point - the display in ddd is a bit kludgie, but its so much better than gdb, that no one has complained much :-)
there is a placement system, but often the display of automatic buffers often messes it up. I think id work on cleanup of those kinds of problems before id go after more complex display system.
....JW
- Badges
- Science topic
- Similar topics
- Computer Science