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:

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