Papers
On this page I will summarize the papers I have read in the course of my work.
Web-based Animation of Data Structures Using JAWAA
authors: Willard T. Pierson and Susan H. Rodger
JAWAA was created to help computer science students to visualize data structures and algorithms and to debug programs that they have written with data structures. Though JAWAA is not the first of its kind, previous programs for this kind of visualization have not often taken advantage of Java and the Web as JAWAA has. The great advantage to JAWAA is how it can be used with programs written in any language on any machine by simply adding one command per line. JAWAA allows the user to create both primitive objects and intelligent objects. Primitive objects include lines, circles, text, rectangles, and polygons. Intelligent objects have commands that specify their behavior in order to represent data structures such as arrays, stacks, queues, graphs, and trees. After these objects have been created, they can have action commands applied to them, which can change different attributes of the object, such as color or position.
JAWAA: Easy Web-Based Animation from CS 0 to Advanced CS Courses
authors: Ayonike Akingbade, Thomas Finley, Diana Jackson, Pretesh Patel, and Susan Rodger
This paper describes JAWAA 2.0, which was created to help enhance learning by allowing students to build animations and run them on the web. JAWAA 2.0 was created with capabilities for more data structures, more features, and an easier way to build JAWAA animations using JAWAA Editor. With the JAWAA Editor, students in classes as low as CS 0 should be able to use JAWAA. JAWAA has primitive objects -- shapes and text -- which have attributes describing their color, position, size, and name. General action commands are used to change these attributes or to remove objects. JAWAA is capable of supporting many different data structures - arrays, stacks, queues, graphs, trees, and linked lists with simple commands.
The next section of the paper describes how JAWAA can be used in classes. In CS 0 students can rely mostly on the JAWAA editor and illustrate simple processes since they are unfamiliar with programming. For CS 1, the code behind the JAWAA animations can still be hidden, to help the students to focus more the programming language they are learning. In CS 2, students can better understand data structures by actually seeing what is happening in each step of the program. One example given for CS 2 is an illustration of a recursive function executing. This includes the actual code, which highlights the line that is currently executing, and a stack which shows instances of the method as they are added to and popped off the stack. JAWAA is capable of being expanded beyond this for more advanced computer science courses.
Tango: A Framework and System for Algorithm Animation (Computer 1990)
author: John T. Stasko
This paper describes a sort of precursor to JAWAA. This program, called “Tango” was created in order for students to understand programs more easily, for developers to spot problems in existing programs or compare the efficiency of similar programs, and for researchers to develop new methods they may not have seen before. One important feature of Tango is its ability to display smooth transitions between states in an animation – which he calls “path-transition paradigm.” Tango consists of the algorithm component (the code that specifies how the animation should behave), the mapping (which translates the algorithm into an animation), and the animation component (which is the graphical representation of what's going on in the program). To use Tango, a developer needs a lot of knowledge of the language. Basically, this older animation framework is much more involved and thus not as easy for beginners to grasp. Still, Tango was one of the pioneers in the attempt to make animation of algorithms simple and easy to understand.
Software Visualization (Book, © 1998 MIT)
editors: John Stasko, John Domingue, Marc H. Brown, and Blaine A. Price
This book describes many aspects of software visualization. Since what I will be working with is algorithm and data structure animation, the chapter on “Fundamental Algorithm Animation Techniques” was particularly relevant. The basic techniques described in this book are:
multiple views – allowing the user to view one aspect of the program at a time
state cues – indicating to the user that the state of the program has changed by a visual change
static history – recording the behavior of the program during runtime to help the user spot patterns and so on
incremental transitions – smooth transition between states, useful for small sets of data to help the user to understand what's happening in between
discrete transitions – instantaneous changes, best used with large sets of data where many small changes will be occurring anyway
multiple algorithms – developers have to take into consideration how more than one algorithm could be displayed at once
input data selection – carefully choosing what data to portray - this includes the amount of input data, pathological data (potentially error-producing for debugging purposes), and cooked data (slightly manipulated for educational purposes)
One of the key points in this book is that visualization does not necessarily mean a picture or graphical representation. For instance, there is a branch of software visualization called “Program Auralization” which communicates information to the user through sound instead of a picture or animation. Their examples were applied to sorting algorithms, using different tones to indicate to the user what was being inserted in a table. Software visualization doesn't exclude graphical representations, though. Visualization even moves into 3D graphics territory. Sometimes a flat, 2D picture doesn't communicate enough information alone. A 3D animation can use different dimensions to portray different attributes.
Rethinking the Evaluation of Algorithm Animations as Learning Aids: An Observational Study (International Journal of Human-Computer Studies 2001)
authors: Colleen Kehoe, John Stasko, and Ashley Taylor
This paper was an attempt to discover how animation may help a student understand and learn algorithms. Algorithm animation has a particular challenge beyond what many other educational animations may face. That is the fact that algorithms have no natural visual representation. To animate an algorithm, one must both translate an abstract idea into a visual, then change that visual over time to illustrate the process. This paper was written in response to previous research that had fairly inconclusive results. On review of this previous research, the authors of the papers decided to focus on one possible reason for why the previous studies did not have positive results: the previous experiments were not designed correctly. Thus, this study was conducted in a fairly unconventional way by attempting to use a more natural environment and observing the students interacting with the program to see how it was used. In conclusion, the researchers hypothesized that the more open environment used in the study better reaps the benefits animation offers. They also hypothesized that animation does assist in learning algorithms.
JHAVÉ – An Environment to Actively Engage Students in Web-based Algorithm Visualizations (SIGCSE 2000)
authors: Thomas L. Naps, James R. Eagan, Laura L. Norton
JHAVÉ (Java-Hosted Algorithm Visualization Environment) is an environment for running algorithm animations. The creators of this program observed some common problems that researchers found in using animations for education. 1) Simply viewing an animation is too passive for a student to gain much of an advantage. 2) The teacher must help the student understand what is going on underneath the animation – what is this animation representing? Otherwise the students will not gain anything from watching. 3) It helps a student's understanding to allow them to “rewind” the animation to view previous states. 4) Increased interaction with the animation tends to increase the students' understanding. JHAVÉ was created to be able to: 1) Provide static pictures as well as animations which can both be “rewound.” 2) Display text that is appropriate to the animation that is being presented. 3) Make the animations interactive by allowing students to enter different input. 4) Bring the student into active participation instead of passive viewing by asking questions periodically.
To try to reach these goals, the creators of JHAVÉ decided not to work on developing yet another system for animating algorithms, but instead to make an environment where other algorithm visualizations can be run. This way, an instructor can use preexisting animations, but add in the advantages listed above. JHAVÉ also makes animations portable that may have previously been limited to a particular operating system by the language in which they were written.
Experiences in Using Animations in Introductory Computer Science Lectures (SIGCSE 2000)
authors: Guido Rößling and Bernd Freisleben
The title of this paper confused me, because the overall paper seems to be describing their animation tool, ANIMAL (A New Interactive Modeler for Animations in Lectures). The last section, only about a quarter of the paper, is the only place where a discussion of “experiences in using animations in introductory computer science lectures” occurs. The first part of this paper describes the classroom environment which the professors are dealing with – more than 200 students with varying experience with programming watching a slide show presentation. The authors created ANIMAL largely due to the fact that existing tools (such as JSamba and JAWAA) didn't have simple ways to highlight source code or pseudo code as the animation progressed. Then a couple of example animations are described: a typical Quicksort animation, and an innovative method for portraying verification with animation. In the last section of the paper they make some general statements about their observations on using their animations in class: Java's memory allocation can be insufficient and slow down animations, including source code is key for enhancing student understanding, using colors to highlight key parts of the animation is a good idea (though student colorblindness should be taken into account when choosing the colors), slide shows with animations can take an unpredictable amount of time because of students' questions and interruptions.
author: Talin
This paper is basically a list of good things to do when designing a user interface. I read this for some suggestions for my work with the JAWAA Editor. Here are the principles and what I have done to try to follow them:
User Profiling – “Know who your user is” – The target users for the JAWAA Editor are computer science professors and beginning students. Thus, the program should be easy for them to use.
Metaphor – “Borrow behaviors from systems familiar to your users” – Although the paper is talking about physical systems, I am trying to make sure that the Editor provides similar functionality to other graphical programs I have used.
Feature Exposure – “Let the user see clearly what functions are available” – This principle was already in place when the program was first built. Three toolbars make editing very accessible.
Coherence – “The behavior of the program should be internally and externally consistent” – Internally, the different options are accessible by dialog boxes, which keep a familiar feel. Externally, I am trying to make sure that the animation that is built in the Editor is the same as the result in JAWAA. Right now, that is not always the case.
State Visualization – “Changes in behavior should be reflected in the appearance of the program” – This principle is a central part of the program, since the changes in behavior are primarily visual – creation, modification, or deletion of primitives. Also, as different objects are selected, the toolbars change to show what options are available.
Shortcuts – “Provide both concrete and abstract ways of getting a task done” – This principle is already included also, since many of the commands can be accessed by a keystroke.
Focus – “Some aspects of the UI attract attention more than others do” – This principle stresses the significance of a changing cursor, since the user tends to watch the cursor move around the screen. The Editor uses a few different cursors to indicate what options are selected (crosspoint for creating shapes, text bar for text objects, pointer for selecting...)
Grammar – “A user interface is a kind of language; know what the rules are” – This principle defines module (action-oriented) and non-module (object-oriented) user interfaces. The Editor is non-module, since the actions that are available depend greatly on the object selected.
Help – “Understand the different kinds of help a user needs” – There is a “Help” menu on the menu bar. This provides help that is goal-oriented, descriptive, and navigational (these terms are defined in the paper). I'm not sure how to meet the Interpretive category, except through using informative error messages.
Safety – “Let the user develop confidence by providing a safety net” – The user should be encouraged to branch out and try new things with the program by reassuring them that their mistakes will not be permanent. This seems to be an obvious call for an Undo feature, which is one of my central goals in my work with the Editor.
Context – “Limit user activity to one well-defined context unless there's a good reason not to” – The context in the Editor is fairly simply defined by which tool is selected and which objects are selected.
Aesthetics – “Create a program of beauty” - As suggested, this program already has buttons that are the same size and it runs fairly smoothly and quickly.
User Testing – “Recruit help in spotting the inevitable defects in your design” – The only help really available to me is my coworker, Gabbie and my mentor, Susan Rodger. Definitely this program should be tested by people who are more like the end users.
Humility – “Listen to what ordinary people have to say” – I guess it'd be nice if the JAWAA Editor allowed for some sort of “customer feedback.”
An Interactive Approach to Formal Languages and Automata with JFLAP
author: Susan H Rodger
Revolutionize the way that FLA courses are taught – no more dependence on pen and paper.
Express who is interested – publishers, 11 universities
Results from prior NSF support – here's how your money went to good use before
tell the amount, time period, grant number
doesn't go into much detail about studying proofs – just lists off different conversions. (good or bad?)
wasn't sure what the parsing stuff meant...
after describing tools, mention how they have been integrated into the classroom
showing feedback from students – good stuff
brag about the widespread use of JFLAP in other countries etcetera.
remind the reader many times how frustrating drawing automata by hand can be for students, and the problems that can arise from this frustration.
discuss the inadequacy of current textbooks – they don't provide nearly enough illustrations, much less interactive software. Hopes are that more visual and interactive learning will enhance students' understanding.
students = deeper understanding, happier & more confident, interested in using materials on their own
instructors = classroom aid, grading tool
plans to write a user's manual
emphasis on building examples that would be too complicated for pencil and paper.
give some concrete scenarios to illustrate the unique method of teaching that is being proposed
plans to make JFLAP flexible to fit any textbook or teaching method
present a timeline to show that the time and money will be used productively
also explain what resources will be used (existing resources and requested resources)
give credit to and explain experience of the people behind the program (Rodger, Linz, Finley) I'm glad to see that Thomas Finley got his fair share of recognition.
showing that the colleges participating in this study are quite diverse, to show that this new teaching method will be tested in many environments
give examples of questions the students and instructors will answer in order to gather info about JFLAP