[pypy-dev] Running Python in reverse

holger krekel hpk at trillke.net
Fri Jan 7 12:28:31 CET 2005

Hi Alexander, 

On Fri, Jan 07, 2005 at 12:04 +0100, Alexander Schliep wrote:
> Christian Tismer encouraged me to post the following directly to the
> pypy mailing list.
> My main Python project is Gato, a software for visualizing (or
> animating) graph algorithms; see
> http://gato.sourceforge.net/wiki/pmwiki.php/Main/Screenshots.  The
> main ingredients of Gato are a debugger subclass, some GUI elements
> and code for drawing graphs.

Looks really nice! 
> The goal is to have an interactive, dynamic version of the classical
> comp.sci. text book, where, typically, some graph algorithm is given
> as pseudo code and you see (at best) a before, during, and after
> snapshot picture of its working on some graph.

makes sense! 
> Python is a perfectly fine replacement for pseudo code and the
> execution and directly coupled visualization, which you can control
> just like a debugger, convey much more than static pictures. Winfried
> Hochstaettler, some university colleagues, and myself have used this
> for teaching discrete math, combinatorial optimization and
> comp.sci.classes with quite favorable comments from everyone involved.
> The number one request was always the ability to track back. I started
> to implement an instant replay of the last visualization effect
> (change of color, blink etc.) and started to think about a proper way
> of supporting the ability to step back in time. This essentially boils
> down to implementing one of the classical design patterns for
> supporting unlimited undo (and redo), treating the visualization
> effects as commands.
> This decouples the state (values of all variables used) of the
> algorithm from the state of the visualization, hence running the
> algorithm after a couple of Undos is not possible (One could fake that
> by Redoing everything and then continuing execution). Supporting an
> update of all variables gets kind of messy in standard Python.

Yes, i see the problem.  At EuroPython 2004 there also was Michael Salib 
who also presented his wish to have a "time warp" debugger that allows
to arbitrarily move within execution time of your program and see all
the state.  And IIRC, we have been discussing this between PyPy developers
a bit sometimes under the term "History Object Space".  An object space
in PyPy encapsulates and manages all state of Python objects and all 
accesses and modifications take place through calling methods on 
such "Space" objects. 

> A cleaner approach would be to have a Python interpreter which can run
> backwards. Christian thinks it would be feasible in PyPy.

Rightfully so.  I wouldn't call it "run backwards" though but to jump
arbitrarily in execution and object states. 
> This actually would be extremely nice for a number of applications
> - teaching Python
> - teaching algorithms with Python
> - debugging in general

Yes, although for debugging in general there is the problem of 
"side effects" like dealing with files & sockets, databases etc.pp.  

> I am somewhat embarrassed to ask for a feature without much to offer.
> But realistically, I cannot promise more than to be a tester and happy
> user.

Well, the question is if we could tackle the "History Space" (working
title) at some sprint and you would attend and we would together incorporate 
the functionality into your application for the fun of it. I imagine
a "time slider" that you can arbitrarily move forward and backward 
which should be feasible especially for pure algorithms like the 
ones you show on your Gato webpage.  With such functionality you
would not need to worry about limited "visualization undo" at all
because you could just cleanly redraw. 



More information about the Pypy-dev mailing list