Visualising Java Data Structures as Graphs

John Hamer

Department of Computer Science

University of Auckland
Private Bag 92019, Auckland New Zealand
Email: [email protected]

Abstract
We present a simple, general-purpose tool for visu-
alising Java data structures. The tool uses Java re-
flection and an open-source graph drawing program
to produce text-book quality depictions of arbitrary digraph NoName {
n1 [label="LinkedList|{size: 3}",
Java objects. shape=record];
The tool offers certain pedagogical advantages over n1 -> n2 [label="header"];
other “heavy-weight” visualisation systems. Its sim- n2 [label="Entry|{null}",shape=record];
plicity and generality means that students are able n2 -> n3 [label="next"];
to visualise their own data structures, rather than n3 [label="Entry|{A}",shape=record];
passively observing a limited range of “correct” visu- n3 -> n4 [label="next"];
alisations prepared in advance by the lecturer. n4 [label="Entry|{B}",shape=record];
The tool supports an active, exploratory style of n4 -> n5 [label="next"];
learning, and is ideally suited for use in CS1-level n5 [label="Entry|{C}",shape=record];
n5 -> n2 [label="next"];
courses that introduce Java references and arrays, as n5 -> n4 [label="previous"];
well as a range of CS2-level data structure material. n4 -> n3 [label="previous"];
Initial classroom results are encouraging. n3 -> n2 [label="previous"];
n2 -> n5 [label="previous"];
}
1 Origins
Our visualisation tool was originally conceived as Figure 1: A graph specified in GraphViz notation
an aid to students learning about linked lists. It
started one evening, when the author wrote a “pretty-
printer” for linked lists that generated a description
suitable for input into the GraphViz graph drawing
utility (see figure 1). GraphViz notation is quite sim-
ple, essentially requiring just the graph edges to be
listed. Node and edge annotations are given in square
brackets. The graph generated from this description
is shown in figure 2. A variety of output formats are
supported by GraphViz, including the widely under-
stood “PNG” (for on-screen viewing) and encapsu-
lated postscript (for printed documents).
The linked list “pretty-printer” turned out to be LinkedList size: 3
of limited use, however. Students could only generate
pictures of “correct” linked lists from code supplied to header

them by the lecturer. They were not able to apply the

technique to their own (often buggy) linked list code, Entry null

or to view the state of any other data structures. Fur-

thermore, code for generating GraphViz output was next previous

included inside the linked list code, and this tended

Entry A
to obscure the more important parts of the code.
All of these limitations were eliminated with the next previous previous next
use of Java reflection. Unlike many “statically linked”
languages like C and C++, Java retains a great deal Entry B
of type information in its compiled (“.class”) files.
This information includes the names, types and mod- next previous
ifiers1 of each class field. Every Java object maintains
Entry C
c
Copyright 2004, Australian Computer Society, Inc. This pa-
per appeared at Sixth Australasian Computer Science Educa-
tion Conference (ACE’2004), Dunedin, New Zealand. Confer-
ences in Research and Practice in Information Technology, Vol. Figure 2: Sample output from GraphViz
30. Raymond Lister and Alison Young, Ed. Reproduction for
academic, not-for profit purposes permitted provided this text
is included.
1
I.e., private, protected, etc.
a link to its class description2 , from which other fields immediate difficulties present themselves. First, class
of the object can be discovered. Reflection thus al- time is lost in explaining the use of the tools. Second,
lows a GraphViz description to be generated for any students are notoriously open to distraction, making
arbitrary Java object by traversing the transitive clo- it all too easy for the substantive course material to
sure of object references. The code that generates be sidelined as students become absorbed with the
this description no longer needs to be attached to the intricacies of the visualisation tool. We argue that
code under study—a simple library call to “gener- an effective visualisation tool must therefore be ex-
ate a snapshot of this object” is sufficient. A series tremely simple to use and provide limited scope for
of snapshots constitutes an animation (albeit free of experimentation. A similar view is expressed by Naps
any smooth interpolation between frames). (1998).
Some further difficulties presented themselves at Our tool:
this stage. In particular, some built-in Java types (no-
tably strings) are actually implemented using charac- • is trivial to setup and easy to use3 ;
ter arrays, although the details of the implementation • engages students in active participation;
are usually kept hidden from the programmer. Java
reflection is sufficiently powerful that these internal • helps students connect their program code with
structure are revealed, as shown in 3. Here it can the Java data model;
be seen that a String object consists of a reference
to a (possibly shared) character array. A string is a • is usable on any Java program, without requir-
subsequence of this array, specified by an offset and ing any specific programming conventions to be
length (a hash value is also stored, to avoid the cost followed;
of recomputation). • allows “wrong” data structures to be viewed as
well as correct ones;
offset: 0
• can be configure to elide unnecessary detail;
java.lang.String count: 5
hash: 0 • allows incorporation of visualisations in reports
and other presentations.
value
The tool presents all of its visualisations in terms
of the Java data model. It is not possible to visu-
H e l l o
alise, say, arrays as bar-charts, or incorporate other
such abstractions. We have also consciously resisted
complicating the tool to support, for example, visuali-
Figure 3: Exploring String internals sation of object-oriented (class inheritance) relations.
Simplicity has been the overriding concern.
This is an insightful representation of a string that
may prove helpful to students in certain contexts (for 3 Overcoming student misconceptions
example, explaining the memory consumption of sub-
string operations), but on the whole it provides far too Java has a complicated data model that includes
much detail. The last stage in achieving a practical primitive types, object types, references to objects,
visualisation tool was the inclusion of a configurable arrays of primitives, arrays of object references, etc.
drawing context. The tool’s drawing context allows Little wonder then that students routinely become
certain classes to be treated as if they were primitive, confused. We have found that our visualisation tool
fields to be hidden, and colour, shape and font at- is highly effective in clarifying student misconceptions
tributes to be set on graph nodes and edges. In most about Java object semantics.
cases, a reasonable default context can be compiled For example:
into the visualiser. Changing the context is quite easy,
and provides students with some scope to explore al- String is not primitive Java goes to some trou-
ternative visualisations. ble to create the illusion that String is a prim-
itive type. A special syntax for constructing
2 Objectives and non-objectives and initialising static strings is provided (double-
quotes), which gives a strong impression that no
In designing the visualisation tool, we have been objects are involved. The default context for our
mindful of the serious pitfalls cited in the literature. visualisation tool partially plays along with this
Foremost amongst these is the need to actively engage illusion, presenting Strings as objects with no in-
students: “Visualisation technology . . . is of little ed- ternal structure. The illusion can be revealed,
ucational value unless it engages learners in an active however, by using an “empty” context, in which
learning activity” (Naps, Rößling, Almstrum, Dann, no elision is performed; e.g., the graph in fig. 3
Fleischer, Hundhausen, Korhonen, Malmi, McNally, was produced with the code fragment:
Rodger & Velźquez-Iturbide 2003), a view echoed by
drawGraph( newContext( ), "Hello" );
Hundhausen & Douglas (2000): “the more actively
involved learners are in the visualisation process, the
better they perform.” Also of concern “is the time Assignment does not create a new object
and effort required for instructors to integrate the The difference between value and reference
technology into their curriculum” (Naps et al. 2003). assignment is an eternal source of confusion for
This effort includes not only the time required to learn students. The visualisation tool clearly shows
new tools and to develop and/or adapt appropriate shared references as links to the same object
visualisations, but the costs of installing (often unre- (fig. 4(a)).
liable) software. 3
To install the system, the system administrator will need to
Active learning typically involves students creat- make sure GraphViz is available on the execution PATH. Students
ing visualisations of their own programs. Here, two need just copy a single Java source file into their working direc-
tory. No changes to the Java environment, such as setting the
2
Primitive types, such as int, boolean, etc., are linked to stan- classpath, are required. Creating a snapshot is a call to a single
dard “wrapper” classes (Integer, Boolean, etc.) that describe these static method. Standard image viewers are perfectly adequate for
built-in types. watching the visualisations.
 In the code that generated this example, an ini-
tialised object array is used to include two objects
in a single graph. This is a general technique that
can be trivially extended to any number of ob- 0 1

jects.
1 2 3
String x = "Hello";
String y = x; 0 1 2
drawGraph( new Object[]{ x, y } );
a b c
The alternative to reference assignment is a copy
assignment, exemplified by the code fragment be-
low (fig. 4(b)).
Figure 5: Object and primitive arrays
String x = "Hello";
String y = new String(x);
drawGraph( new Object[]{ x, y } );

0 1 2 3

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 1 0 1
Figure 6: Java 2d arrays

Hello Hello Hello drawGraph( new int[4][5] );

(a) Reference assign- (b) Value assignment Static fields are not part of any object This
ment
fact is reinforced in every visualisation. Static
fields are not displayed except in the (unusual)
case of an explicit reference to a static object.
We have found this an especially helpful property
0 1 of the visualisation tool, as students quickly re-
frain from adding spurious static modifiers to
offset: 0 offset: 0 fields when they find nothing appears in their
java.lang.String count: 5 java.lang.String count: 5 graph!
hash: 0 hash: 0
We have also found that the visualiser helps
value value discourage students from declaring unnecessary
fields, since these add clutter to all their graphs.
H e l l o
4 Customising the drawing context
(c) Shallow copying
A drawing context is used to control the appearance
of graph nodes and edges, to elide classes and fields,
Figure 4: Reference and value assignment and to control the format and naming of output files.
Alternatively, an “empty” context can be used A default drawing context can be configured to
to reveal the extent to which copying of strings give reasonable defaults, such as ignoring inaccessible
actually occurs (fig. 4(c)). Examples such as this fields or treating system classes as primitive types.
are useful for introducing the concept of “shal- Configuration of the drawing context is ongoing.
low” versus “deep” copying. The operations currently supported include:

String x = "Hello"; setClassAttribute, setFieldAttribute

String y = new String(x); Attributes include border and font colour,
drawGraph( newContext( ), new Object[]{ x, y } );
font size, fill style, etc. For example, a binary
tree node can be made bright pink and different
Object arrays hold references An array of inte- colours given to the left and right links as
follows:
gers and an array of strings are modelled very
differently in Java. Our visualisation tool clearly Context ctx = getDefaultContext( );
captures this distinction, displaying primitive ctx.setClassAttribute( Node.class, "color=pink" );
values inline and displaying object values as sep- ctx.setFieldAttribute( "left", "color=red" );
arate nodes (fig. 5). ctx.setFieldAttribute( "right", "color=blue" );

drawGraph( new Object[]{ The available attributes are determined by the

new String[]{ "a", "b", "c" }, GraphViz tool.
new int[]{ 1, 2, 3 } } );
Fields can be set by name (as above) or by spe-
cific reference.
2-dimensional arrays A very simple illustration of
how 2-dimensional arrays are represented in the treatAsPrimitive The specified class is treated as
Java data model is given in fig. 6. The code that a primitive value; i.e., the result of calling
produced this visualisation is trivial; it simply toString on the object is displayed in-line,
create a rectangular 2-d array (so that the row rather than showing the object as a separate
and column ordinates can be deduced). node.
 This is a surprisingly effective mechanism for re-
ducing the amount of clutter in a visualisation.
startM: 1
Most Java classes provide a toString method
that conveys the content of the object as a string. startB: 4
Deque
This includes all the Java collection types (lists, finishM: 2
maps, etc.). Ellipsis (“. . . ”) can be inserted to finishB: 4
replace the middle of excessively long strings.
map
ignoreField Suppresses display of the given field.
ignorePrivateFields A boolean value. If set (the
default), fields that are not normally accessible
are not displayed. This includes protected fields 1 2
in other classes, and package-visible fields from
other packages.
null null null null H G F E D null
showFieldNamesInLabels Determines whether
field names should be displayed in nodes or not.
qualifyNestedClassNames Nested classes are Figure 7: Visualising a Deque
given compound names by the Java compiler;
e.g., a class Entry nested in a class LinkedList
will be named LinkedList$Entry. Normally,
only the last part of these names is displayed. size: 4
Setting this option results in the full name being TreeMap
used. modCount: 4

outputFormat This string field determines the out- root

put format. The default is png, a widely used
image format. The ps (encapsulated postscript) key: three
format can also be used for generating high- Entry value: 3
resolution scalable graphs suitable for including color: true
in reports.
baseFileName A numeric suffix is added to give left parent right parent
a unique name for each output graph (e.g.,
graph-0.png, graph-1.png, etc.) The set of key: one key: two
graphs so generated can then be viewed as a slide Entry value: 1 Entry value: 2
show using a standard image viewer. color: true color: true

5 Data structure examples left parent

We present several visualisations generated by our key: four

tool for the major data structures studied in a CS2- Entry value: 4
level course. color: false
The first example (fig. 2) is a visualisation of the
standard Java linked list class, and was generated
from the following code fragment. Figure 8: Visualising a red-black tree
List xs = new LinkedList( );
xs.add( "A" );
xs.add( "B" );
xs.add( "C" );
defaultContext( ).ignorePrivateFields = false; size: 3
drawGraph( xs ); threshold: 8
HashMap
loadFactor: 2.0
A deque data structure is shown in fig. 7. The modCount: 3
snapshot, taken after 8 elements were added and then
3 removed, shows the relationship between the deque table
indexes (_startM, etc.) and the map and element
buffers. The free space at both ends of the deque and
the contiguous storage of elements are clearly appar-
ent.
0 2
A red-black tree is shown in fig. 8. This exam-
ple suggests the need for a drawing context that will
key: three key: two
select the colour attribute from an object field.
Entry value: 3 Entry value: 2
Finally, we present a chained hash map (fig. 9).
hash: -741826716 hash: -1000502134
This diagram was obtained from the Java library
class, using a display context that included private next
fields.
key: one
Map hm = new HashMap( 4, 1.0f );
Entry value: 1
hm.put( "one", new Integer(1) );
hm.put( "two", new Integer(2) ); hash: -953555362
hm.put( "three", new Integer(3) );
getDefaultContext( ).ignorePrivateFields = false;
drawGraph( hm ); Figure 9: Visualising a Hash table
6 Related and future work Hundhausen, C. & Douglas, S. (2000), Using visu-
alizations to learn algorithms: Should students
GraphViz is just one of many many free and com- construct their own, or view an expert’s?, in
mercial graph drawing tools currently available (e.g., ‘IEEE International Symposium on Visual Lan-
see (Google.com 2003)). GraphViz was chosen be- guages’, pp. 21–30.
cause of its ease of installation, simple interface,
and the aesthetic quality of the generated graphs. Naps, T. (1998), A Java visualizer class: Incorporat-
DaVinci (Fröhlich & Werner 1994), another popular ing algorithm visualizations into students’ pro-
graph drawing tool, can be driven through an API, grams, in ‘Proceedings of ITiCSE’98’, Dublin,
making it better suited to displaying graphs while the Ireland, pp. 181–184.
program is running. Unfortunately, this would nec- Naps, T. L., Rößling, G., Almstrum, V., Dann, W.,
essarily require setting up a non-standard Java envi- Fleischer, R., Hundhausen, C., Korhonen, A.,
ronment, thus violating one of our stated aims. Malmi, L., McNally, M., Rodger, S. & Velźquez-
North & Koutsofios (1994) presents a survey of Iturbide, J. A. (2003), ‘Exploring the role of vi-
graph visualisation applications, which includes men- sualization and engagement in computer science
tion of a prototype visual debugger, vdbx. vdbx sits education’, ACM SIGCSE Bulletin 35(2), 131–
on top of the widely used dbx debugger, and con- 152.
tains a parser that translates dbx-syntax C “structs”
(i.e., records) into graph notation, allowing pointer North, S. C. & Koutsofios, E. (1994), Application of
structures to be browsed graphically while debugging. graph visualization, in ‘Proceedings of Graphics
This is an appealing idea, although the tool itself ap- Interface ’94’, Banff, Alberta, Canada, pp. 235–
pears to have fallen into disuse. 245.
Recent releases of Java include a “platform debug- URL: citeseer.nj.nec.com/ 221206.html
ger interface” (Sun Microsystems 2003) that is used
by a wide variety of debugging tools. We are currently Sun Microsystems (2003).
investigating adapting one of these tools to display URL: http:// java.sun.com/ products/ jpda/
graph visualisations along the lines of vdbx.
Gestwicki & Jayaraman (2002) present JIVE, an
interactive Java object “inspector.” JIVE incorpo-
rates some novel ideas for representing inheritance
relations, and for displaying the currently executing
source line next to the displayed objects. The cur-
rent implementation of JIVE requires a source code
transformation step, which the authors hope to re-
place with direct calls to the Java platform debugger.
Pedagogically, Naps’s Visualiser class (Naps
1998) shares much in common with the work pre-
sented here, with both approaches emphasising the
need for a tool simple enough for students to use with-
out unnecessary distraction. Our visualiser is more
general, does not require any special configuration to
handle new data structures, and is slightly easier to
use. Naps’s approach allows greater freedom in the
presentation of data (e.g., bar charts for integer ar-
rays) and supports arbitrary customisation.

7 Availability
The visualisation tool, comprising a single Java source
file, can be requested by emailing the author.
The GraphViz utility can be downloaded for free
from http:// www.graphviz.org.

References
Fröhlich, M. & Werner, M. (1994), Demonstration
of the interactive graph visualization system
daVinci, in R. Tamassia & I. Tollis, eds,
‘Proceedings of DIMACS Workshop on Graph
Drawing ‘94’, Vol. 894, Springer Verlag, Prince-
ton (USA).
URL: ftp:// ftp.Uni-Bremen.DE/ pub/
graphics/ daVinci/ papers/ lncs.ps.gz
Gestwicki, P. & Jayaraman, B. (2002), Interactive vi-
sualization of Java programs, in ‘Symposia on
Human Centric Computing Languages and Envi-
ronments (HCC’02)’, IEEE, Arlington, Virginia,
USA, pp. 226–235.
Google.com (2003).
URL: http:// directory.google.com/ Top/
Science/ Math/ Combinatorics/ Software/
Graph˙ Drawing/