[Paper Review] Algorithms Visualization Tool for Students and Lectures in Computer Science

Kaninda Musumbu|arXiv (Cornell University)|Mar 18, 2014

Engineering and Information Technology3 citations

TL;DR

This paper presents jAlgo, a Java-based visualization tool designed for computer science students and lecturers to animate, debug, and understand classical algorithms through graphical, descriptive, and formal representations. The tool enables users to write, compile, and step-through custom algorithms in a high-level language with real-time visualization, synchronization, and multiview editing, significantly enhancing algorithm comprehension and pedagogical effectiveness.

ABSTRACT

The best way to understand complex data structures or algorithm is to see them in action. The present work presents a new tool, especially useful for students and lecturers in computer science. It is written in Java and developed at Bordeaux University of Sciences and Technology. Its purposes is to help students in understanding classical algorithms by illustrating them in different ways: graphical (animated), formal, and descriptive. We think that it can be useful to everyone interested in algorithms, in particular to students in computer science that want to beef up their readings and university lecturers in their major effort to enhance the data structures and algorithms course. The main new thing of this tool is the fact of making it possible to the user to animate their own algorithms.

Motivation & Objective

• To address the lack of comprehensive, pedagogically effective algorithm visualization tools for computer science education.
• To support students in self-directed learning by enabling them to visualize and debug algorithms they write.
• To provide lecturers with a dynamic, real-time teaching aid to enhance data structures and algorithms courses.
• To enable users to write, compile, and animate their own algorithms using a custom high-level language.
• To achieve accurate synchronization between code execution and visual representation through frame-based animation and observer pattern.

Proposed method

• The tool uses a custom high-level algorithmic language called jAlgo, designed for clarity and expressiveness in educational contexts.
• A compiler is implemented to detect lexical, syntactic, and semantic errors, generating abstract syntax trees and target code.
• The system employs a frame-based visualization model, where each frame captures execution state, highlighted instructions, and data structure changes.
• The observer pattern is used to decouple the execution engine from the visualization layer, enabling real-time data propagation.
• A multiview interface displays both the algorithm code and the animated data structure simultaneously, improving comprehension.
• The tool supports binary trees and plans future support for graphs and finite-state machines.

Experimental results

Research questions

• RQ1 How can a visualization tool improve the understanding of classical algorithms among computer science students?
• RQ2 What design principles enable effective synchronization between algorithm execution and visual representation?
• RQ3 To what extent can a custom programming language enhance the teaching and learning of algorithms?
• RQ4 How can a tool support both student self-study and lecturer-led instruction in algorithm courses?
• RQ5 What features are essential for a visualization tool to be both pedagogically effective and user-friendly?

Key findings

• The jAlgo tool successfully enables users to write, compile, and animate custom algorithms in a high-level, intuitive language.
• The frame-based visualization model with synchronized execution and graphical updates significantly improves algorithm comprehension.
• The use of a compiler with error detection and abstract syntax trees ensures correctness and supports pedagogical feedback.
• The multiview interface, combining code and animation, enhances learning by allowing real-time correlation between logic and structure.
• The tool’s extensibility supports future integration of graphs and finite-state machines, expanding its educational scope.
• User feedback indicates that animation helps identify logical flaws in algorithms during self-study, reinforcing the tool’s value in algorithm development.