The Extensible Dynamically Configurable Visualization Framework Animal
Guido Rößling
University of Siegen
Department of Electrical Engineering and Computer Science
Hölderlinstr. 3
57068 Siegen
Germany
Email:
roessling@acm.org
Expected date of completion: September 2001
Problem and Motivation
Computer-assisted instruction has been used for several decades. One
popular use is visualization, both for (slide) presentation and
algorithm and data structure animation. Several commercial or free
presentation tools are available. However, these tools are usually ill
suited for algorithm animation due to lack of specific support for
"typical" data structures and operations. On the other hand, tools
geared for animation are often unsuited for slide presentations, for
example due to a lack of support for adding explanatory texts or
highlighting elements. Having a single tool that supports both
presentation and algorithm animation contents helps users by not
forcing them to learn using several tools, and preventing them from
having to switch tool during presentation.
A combined tool should possess several features to be usable in a
wide area of applications. This can basically be resolved in two
different ways: by offering a large tool that tries to encapsulate all
possible uses, or by providing a framework that can be extended by
users. The framework shall be able to offer both the features needed
in a presentation tool, such as cascaded item lists, and those
required for generic algorithm animation.
Background and Related Work
A number of popular presentation tools are available, often embedded
in office suites such as Star Office. These tools are geared for
presentations as in a conferences or meetings, and thus satisfy most
expectations for this venue. However, due to their lack of support
for either special data structures, built-in algorithms or
interpreters, they are of little use for showing the dynamics of
algorithms and data structures. Furthermore, they normally do not
allow easy automation: everything that is shown on a given slide
typically has to be generated manually.
Several free animation tools are also available. Probably the most
"visible" tools in educational computer science publications currently
are Susan Rodger's JAWAA [2], John Stasko's JSamba [4] and the Jeliot system by Haajanen, Sutinen et.al. [1]. JAWAA and JSamba allow generic animations defined
in a built-in scripting language, offering at least partial support
for basic data structures. Jeliot performs an automatic visualization
of Java source code. Automatic visualization generation is supported
by generated scripting code for JAWAA or JSamba, or modifying source code and
parameter values for Jeliot.
However, these tools also have some inherent limitations:
scripting-based tools are restricted by the features offered in the
fixed scripting language, while source code-based tools cannot easily
determine the most appropriate visualization of user-defined data
structures. JAWAA and JSamba could in principle be used for slide
presentations; however, they do not support user-specified timing for
operations and typical presentation elements such as item
lists. Support for these features could in principle be provided, if
the user is willing to modify the tools' source code.
One main aspect lacking in many tools is extensibility,
for example by enabling the user to supply new scripting language
commands. Other lacking features include adaptability and
dynamic (re-)configuration, for example for exchanging the
language used throughout the system, choosing import/export formats,
extending or limiting the features visible for students, or even
changing the semantics of key controls.
Goal of My Research
I am working on designing and developing a platform-neutral
visualization tool called Animal that tries to resolve these
issues by being designed to be as open for adaptations and extensions
as possible. To address the largest possible user audience,
Animal visualizations can be generated manually using drag
and drop, by using the built-in scripting support for
AnimalScript, via method calls in a special Java API, or by
importing from a selection of other formats. Thus, novice users may
use the graphical front-end for generating their animation. More
experienced users will probably resort to the scripting language or
API calls, which also allows for easy automatic generation of
visualizations.
I want to make Animal open for extensions in the following
areas:
- supported primitive graphic objects
Animal
comes with built-in support for the standard graphic primitives
point, polyline, polygon, arc, text and list
elements. Users shall be able to add new primitives easily
without requiring much programming knowledge.
- supported animation effects
Animal supports
the basic effects show, hide, move, rotate and change
color. All effects can be timed using offset and duration on an
internal time unit or millisecond base. Any user shall be able to add
new effects such as scaling or dissolving.
- supported import and export filters
Animal
currently imports its own binary and ASCII-based format and has an
experimental JSamba import filter. All animations can
currently be exported in Animal's binary and ASCII-based format
(optionally compressed), XML, various image formats (also as
a sequence of images for showing the dynamic effects), and as a
Quicktime movie (under development).
Animal's implementation does not fix the available object
types within the code. It relies on the Java reflection mechanisms
for locating and loading objects at start-up depending on several
configuration files. Other advanced Java features such as
ResourceBundle and AbstractAction are also widely
used.
The currently registered primitives, effects and format filters are
listed in one configuration file each. Users can easily adapt the
features offered by Animal to the ones they want or want
other users to see. The files are located dynamically at start-up
following the Java CLASSPATH settings and thus can be duplicated with
different settings in the same file system. For example, a developer
may include experimental features into the system that others will not
be aware of, although they may be contained in the same Java JAR file.
Educators could also provide a limited selection of available effects
and types to their students and encourage them to extend the system
with a given "new" type. Removing an entry of the configuration file
makes the associated component unavailable to the system. Adding an
entry to the appropriate configuration file adds new components or
makes formerly removed components available.
One of the main benefits of this approach is that changing the
configuration is sufficient to providing new objects - not a single
line of code has to be modified. This also means that implementers of
new features do not have to browse through the large Animal
source code (about 60,000 lines of code at present) to find out where
they have to hard-wire their additions into the system.
I hope to end up with a tool that can be used (nearly) universally
for all algorithm animation aspects. Hopefully, this will allow others to
save the time needed for implementing their own blend of visualization
tool because they miss one or two features. Incidentally, this was
the reason that originally led to the implementation of
Animal, too.
Current Status
I have finished most of the basic implementation. Some additional
features such as Quicktime movie generation or Servlet-based
generation of animations are currently being implemented. I hope to
finish the implementation before the SIGCSE conference and will then
start writing my thesis. The current public release of
Animal is available online [3], but does not
represent the current development status. However, while this public
release already contains a few of the aspects central to my research,
they are not visible to the user.
What Do I Hope To Gain From Participating in the DC
I hope to get into contact with others who are interested in
visualization or adaptive software. So far, each conference I have
attended has given me new ideas and outlined other aspects that I can
address. I hope to receive some advice from the consortium
leaders on my work. Finally, and perhaps most importantly, I look
forward to active discussions with colleagues about my and their work.
Bibliographic References
- [1]
- J. Haajanen, M. Pesonius, E. Sutinen, J. Tarhio,
T. Teräsvirta, P. Vanninen (1997). Animation of User Algorithms on
the Web., IEEE Symposium on Visual Languages, IEEE Press,
pp. 360-367.
Jeliot is available online at
http://verosaari.cs.helsinki.fi:8807/Jeliot/www/
- [2]
- Susan Rodger. JAWAA and Other Resources (1997). Available online
at http://www.cs.duke.edu/~rodger/tools/tools.html
- [3]
- Guido Rößling (2000). Animal Visualization
Tool. Available online at http://www.informatik.uni-siegen.de/~roesslin/Animal/index.html.
- [4]
- John Stasko (1998). Samba Algorithm Animation System. Available
online at http://www.cc.gatech.edu/gvu/softviz/algoanim/samba.html