It's easy to forget how much we have to remember inside our heads just to work with code. And why? Much of this work could and should be done by the machine, which would free us to focus on what we want. But the need for context, different execution environments, etc, all make this difficult to tackle generally.
More and more lately, I find that I'm interested in this problem more than the code itself.
I remember checking out this book on graph drawing, and realizing how hard a problem drawing arbitrary data structures is. And what about functional code? How do we visualize stateless algorithms?
I deeply want this to exist though. I feel like, much in the same way excel secretely represents the core of what we want to do with computers, data structure visualizations is the core of how we want to read code, especially in "tight" code involving heavily coupled structures.
Although I think aiming for building this into the general programmer's development environment is ideal, there is an easier first step. Simplify and reduce the scope of the project to where you build this into a pedagogical programming environment. Most programmers have solidified these mental models into their heads. We only need to see them when we've made an error. Students, on the other hand, are flying blind and need this visualization desperately. More than that, the types of programs students build are highly constrained assignments which are more amenable to visualization.
people are starting to play with interesting techniques for augmenting programming like:
Me too! In fact, I'm spending all my free time by working on making progress in this field.
I remember doing one of the Project Euler's problems, something in the vein of "you are given a 20x20 matrix, find an element for which the sum of the elements around it is maximum". Nothing complicated, right? You just iterate over rows, then over columns, then throw in a check for zero index and the max boundary index, then do this for both x and y, etc. When I was done with the problem (nested for loops, five if checks inside), I found someone else's solution in Haskell on Project Euler's forums. A point-free one-liner with bunch of smart folds.
That's the power of abstraction.
The visualization for B-trees and Red/black trees was totally invaluable!
It is specific to red-black trees, but I am considering adding other data structure manipulation algorithms as well.
On insert and delete, you can single-step forward and backward and see the tree manipulations at each step. Or, you can do the entire operation at once.
There is pseudo-code for insert and delete, and at each forward or backward step the line of code being executed is highlighted.
Edit: And why doesn't Google find the good stuff when I am looking for it ...?! :-)
I really appreciate how he writes his articles. More people should do this, with the interactive illustrations.
very sweet project tho!
Ironically (or perhaps coincidentally), I got my non-technical degree from the very school this is hosted on.