Discussion questions from CS 7390 lecture

Date: 1/19/96

Presented by: Mike

Topic: Data Structure Display 2

• When you are looking at one portion of the list and a change occurs elsewhere, I see ther following problem: Usually a person debugging wants to know about the state of something right before a change as well as right afterwards. But if they were looking at a different portion of the list, how can they find this out ?
• Why VIPS does not show all the links in the whole window? Or at least allow users to click a node to display extra links, if for the sake of clarity.
• SGI's visual debugger provides much of what VIPS does for linked lists, but it is very confusing to use because the changes during execution are instantaneous. Why don'ty these debugger try to animate changes to make them easier to follow?
• Would it be usefull if multiple views of the linked-list display were available as layers like a CAD program. This would allow each display more screen estate.

• The GDBX paper talks about leaving diagrams where they were originally drawn during update. How do they deal with dynamically groing structures?
• GDBX tries to display everything on a single virtual screen. But for large structures, linked-lists and arrays, is it better to dispay them in separate windows, so they ccan be hidden and unhidden, and rearranged by the user?
• Could someone please explain why GDBX makes a distinction between what is "constructed" and what is "presented" ?
• Does GDBX require too much effort for the users when they are simply using it for debugging? If so, how can more of the work be automated?
• GDBX was a success-story for graphical debuggers according to Baskerville. His performance data showed running time for GDBX. However, no empirical data from users debugging with GDBX was presented to support the first claim that it is "successful" in aiding debugging. My question is this: how can you set up a controlled experiment to test GDBX usefulness ?
• Could we give debugging commands in the form of a script to GDBX and have it animate the data structure ?
• Why stick with a textual interface when the guy is already there? Just add some buttons and forms ...

• Compare the virtual window with scrollbar method of GDBX to the whole-list window with list outline and partial list window with more detail of VIPS. Both are trying to show the full view with detail availability - how successful are they ?
• As shown in the papers, visualizing linked lists can be quite useful for program debugging. Would it be feasible for the visualization program to automatically detect if a list conforms to one of the common types, i.e. stack, singly or doubly linked lists, trees, etc. and to then display the list in a meaningful way?
• The benefit of visualizing variables and data structures in graphical debuggers is obvious. Would it be useful to incorporate some sort of animation to indicate when variables or structures interact, rather than just showing the end results ? For debugging linked lists, it might be nice to see a node created which then move to the stack, queue, or whatever and is attached.
• VIPS and GDBX make claims that data structure visualization is very important in debugging. VIPS claims: "linked list visualization is one of the most important facilities for debuggers! Why ? What is the base of that claim? It seems to me that pointer and data structure errors would be only a small portion of debugging problems. Can graphical debuggers help with other debugging problems ?
• Both papers insist on the utility to represent data structure graphically in a debugger. What else could you put in a graphical interface of a debugger ?
• In which application (other than debugging) could these structure graphical representation be used.
• Both papers had similar paradigm for displaying changes in data structures, but it seems to suffer from having to compromise between displaying a large amount of data and being able to effectively follow changes. How about a system where the view changes/moves to the data structure being modified ? Would that be more effective?
• Why do so many of these debuggers use simple boxes and arrows? It seems like so much more information could be conveyed more quickly with different graphical icons representing different data types, especially if you `re trying to convey a lot of info in a limited-size window.