Tue Mar 13 16:58:58 EDT 2007
PSIBER (PostScript Interactive Bug Eradication Routines) was an
experimental approach I took to making a visual programming interface
and interactive debugger for the PostScript interpreter in NeWS.
The idea wasn't to invent a new visual language, just to implement a
faithful visual representation of how the language really is, with a
direct manipulation interface for editing data and executing code. (With
drag and drop, pie menus, tabbed windows, direct stack manipulation,
scaled outlines, embedded editors, etc!)
PostScript is a lot like Lisp (in some ways more so than Python),
because PostScript programs are simply executable arrays containing
names, literals, primitive operators, nested arrays, etc.
So a general purpose PostScript structure editor can explore and edit
any PostScript program, or even a NeWS thread's state, dictionary stack,
operand stack and execution stack, so it's a useful component of an
Python AST trees might be a good way to translate back and forth between
editable structures and Python code.
Although (since Python ASTs weren't designed to be human editable) it
might benefit from another layer of translation to pretty them up and
digest them, so they can be easily edited.
I think it would be wonderful to have a visual interface that faithfully
represented the full power and semantics of Python (without trying to
put a "kid friendly" facade over it), so you could use it to examine and
debug any running Python program.
Of course there's still a need for many different simple
application-specific "kid friendly" visual languages, but when you drill
down to real code, it's best to get the real thing (full access to
everything Python can do, visually) instead of some annoying
watered-down half-baked ersatz Python (like "safe python" in Zope, or
smarty templates in PHP).
The Shape of PSIBER Space - October 1989
The Shape of PSIBER Space:
PostScript Interactive Bug Eradication Routines
Written by Don Hopkins, October 1989.
University of Maryland
Human-Computer Interaction Lab
Computer Science Department
College Park, Maryland 20742
The PSIBER Space Deck is an interactive visual user interface to a
graphical programming environment, the NeWS window system. It lets you
display, manipulate, and navigate the data structures, programs, and
processes living in the virtual memory space of NeWS. It is useful as a
debugging tool, and as a hands on way to learn about programming in
PostScript and NeWS.
[Gratuitous Gibson quote omitted]
The PSIBER Space Deck is a programming tool that lets you graphically
display, manipulate, and navigate the many PostScript data structures,
programs, and processes living in the virtual memory space of NeWS.
The Network extensible Window System (NeWS) is a multitasking object
oriented PostScript programming environment. NeWS programs and data
structures make up the window system kernel, the user interface toolkit,
and even entire applications.
The PSIBER Space Deck is one such application, written entirely in
PostScript, the result of an experiment in using a graphical programming
environment to construct an interactive visual user interface to itself.
It displays views of structured data objects in overlapping windows that
can be moved around on the screen, and manipulated with the mouse: you
can copy and paste data structures from place to place, execute them,
edit them, open up compound objects to see their internal structure,
adjust the scale to shrink or magnify parts of the display, and pop up
menus of other useful commands. Deep or complex data structures can be
more easily grasped by applying various views to them.
There is a text window onto a NeWS process, a PostScript interpreter
with which you can interact (as with an "|executive|"). PostScript is a
stack based language, so the window has a spike sticking up out of it,
representing the process's operand stack. Objects on the process's stack
are displayed in windows with their tabs pinned on the spike. (See
figure 1) You can feed PostScript expressions to the interpreter by
typing them with the keyboard, or pointing and clicking at them with the
mouse, and the stack display will be dynamically updated to show the
Guido van Rossum wrote:
> On 3/11/07, Andrew Clunis <orospakr at linux.ca> wrote:
>> Antoine van Gelder wrote:
>> > Don Hopkins wrote:
>> >> Of course it might just be more powerful and efficient to
>> >> something like Klik-and-Play from scratch in Python, as a plug-in
>> >> visual scripting component, which can be used to script a
>> >> HyperCard-like gui environment, and games built on top of it like
>> >> SimCity and Robot Odyssey.
>> > Anyone know the current status of being able to turn an AST tree
>> > by the Python compiler module back into code after it has been
>> modified ?
>> I've been looking into this for Develop activity, but it seems that path
>> has never been explored. Best approach seems to be to write a
>> pretty-printer to walk the tree.
> I'm curious about the focus on ASTs that seems apparent in this
> subthread (though I may easily be misreading between the lines :-).
> I've always been more inclined to edit the text and re-parse from
> there, as it puts the author in control of formatting, comments etc.,
> and this is how most "real-world" environments work. (Not that that
> necessarily makes it better, but neither is the opposite true.) Is
> someone willing to write up a brief comparison between the two
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Sugar-devel