This legacy web site is no longer updated but will remain online for the foreseeable future. UUhistle is not being actively supported or developed. Successor systems include Jsvee and Kelmu.
About UUhistle and Learning to Program
UUhistle is a tool whose purpose is to help novice programmers become better programmers. It allows students to explore the execution-time behavior of computer programs visually and interactively.
In an introductory programming course, UUhistle can be used in a number of ways, outlined below.
(Reading the explanations below is all well and good, but don't forget to try it out for yourself.)
Using UUhistle to View Programs
UUhistle gives a detailed step-by-step account of how a computer program executes. It visualizes as abstract graphics some relevant contents of computer memory such as variables, the call stack, and the heap. This screenshot shows UUhistle paused in the middle of the execution of a short Python program.
(Click for a larger image)
UUhistle shows changes in program state as smooth animations accompanied by textual explanations. The user can control the pace of execution, and step back and forth within the execution sequence. UUhistle highlights many aspects of program execution that are otherwise hidden and often challenging to the novice: expression evaluation, parameter passing, return values, reference assignment, object initialization, etc.
Programming students can use UUhistle to explore teacher-given example programs or they can use it as a graphical, very detailed sort of debugger on programs that they wrote themselves. Using UUhistle can help students to develop their code-reading and tracing skills and to improve their understandings of programming concepts and programming-language constructs. It may also serve as a stepping stone towards efficiently using regular debuggers. Ultimately (albeit indirectly), UUhistle aims to improve students' skill at writing programs.
Using UUhistle in Interactive Coding Mode
UUhistle features an interactive coding mode, which allows the user to mix code-writing and execution in much the same way as a typical Python interpreter's interactive mode does. Each input is executed immediately. UUhistle's interactive coding mode adds three things to a typical interactive interpreter session:
- UUhistle shows a detailed visualization of how each input is executed.
- UUhistle conveniently displays all earlier inputs to make it easier to keep track of how the current state was reached.
- UUhistle allows you to step back and forth in the session history (undoing and redoing inputs) via the control buttons.
The interactive coding mode allows the user to flexibly and conveniently explore and illustrate the semantics of Python code.
Here is a screenshot of UUhistle in the interactive coding mode.
(Click for a larger image)
Just viewing programs isn't the whole story, however...
Using UUhistle for Visual Program Simulation Exercises
Visualizing a program's execution can aid understanding, but research suggests that visualizations are more effective when learners are actively engaged in manipulating or creating them. To this end, UUhistle supports a novel kind of highly interactive visualization-based activity, the visual program simulation exercise (or VPS exercise for short).
In a VPS exercise, the student has to 'do the computer's job': read given code and execute its statements in the appropriate order, allocating and using memory to keep track of program state. UUhistle provides the graphical elements that the student directly manipulates to indicate what happens during execution, and where, and when. Any aspect of execution that UUhistle can display can also serve as part of a VPS exercise: the student can create variables and objects in memory, evaluate expressions, assign values, manipulate the call stack, pass parameters and so forth. For instance, to assign a variable's value to another variable, the student drags the corresponding graphical element with the mouse from the source variable into the target variable.
In the screenshot below, a user is simulating a program's execution in UUhistle, and is now in the process of calling a function. He has just clicked on the call stack to bring up a context menu that allows him to create a new stack frame.
(Click for a larger image)
A VPS exercise challenges the student to really think about what is going on in UUhistle's visual representation of the given program. Just staring at the pretty colors isn't enough!
Programming teachers can use UUhistle as a platform for providing VPS exercises to students. By completing a VPS exercise, the student not only learns but also demonstrates (to themselves and perhaps to a teacher) that they have learned. UUhistle can automatically grade students' solutions and submit grades to web-based courseware.
Using UUhistle for Other Assignments
UUhistle allows the teacher to embed various sorts of popup dialogs into example programs. These dialogs can, for instance, ask multiple-choice questions at preset points during a program run, as shown in the screenshot below.
(Click for a larger image)
Using UUhistle as a Presentation Tool
Last and possibly not least, teachers may find UUhistle useful as a presentation tool in class when illustrating the behavior of example programs.
Further Reading
Questions and answers in the FAQ
Technical Documentation for programming teachers
Academic publications about UUhistle