When I was a kid, I had a cartridge for my Atari 1200XL computer
called "Delta Drawing" by Spinnaker (an edu. software company from back then).
(I probably still have this cart, somewhere. I _do_ have a couple of
Atari 8-bit computers, and one's hooked up to the family TV. :) )
Delta Drawing is a turtle graphics environment, like we're all probably
familiar with from the Logo programming language. However, unlike Logo
(or most, if not all, other languages with turtle graphics), it's has a
distinctive immediacy.
Instead of typing a program:
pendown
forward 10
right 120
forward 10
right 120
forward 10
and then requesting that this program be executed, you simply instruct the
turtle using single keypresses, and it responds right away:
[D] (move forward and a short distance, drawing)
[R] [R] [R] [R] (turn right 30 degrees... four times)
[D]
[R] [R] [R] [R]
[D]
Alternatively, you can request that a command be repeated a number of times;
the above could be executed as:
[D]
[4] [R]
[D]
[4] [R]
[D]
Using modifier keys ([Shift] and [Control]), some commands can be altered.
For example, [Shift]+[R] rotates right 15 degrees. [Control]+[R] only 1 degree.
(So the rotations above could be done using "[1] [2] [0] [Ctrl]+[R]", too.)
One fun aspect to how the environment worked is that you could use the
[Backspace] key to 'undo' a command. It literally undid the previous
steps. Hitting [Backspace] 2 times with the above example, the
turtle would move back (removing the third line), and un-rotate 30 degrees.
(And the recorded program would change to: [D] [4] [R] [D] [3] [R])
On the one hand, the immediacy limits how and what you can program.
(No variables, limited looping capabilities, no user input -- aside from the
program itself! -- no recursion.)
On the other hand, I think this kind of immediacy can be helpful in making
turtle graphics (and geometry, numbers/math, art and programming) more
accessible.
A kid doesn't have to know that they're writing a program... they simply
push the buttons and the drawing happens. Eventually, they can learn how
subroutines help them modularize what they're doing, and allow for patterns.
Finally, they could 'graduate' to a real programming environment like
UCB Logo or Kturtle or something else...
I've started working on something (in my 'copious' free time :^P ) that
I'm calling "Tux's Turtle" (to go with Tux4Kids' Tux the penguin branding),
although at this point there's no Tux. :)
It has a novel way of showing a subroutine being created... a little
thought bubble pops up from the turtle, with a miniature canvas and turtle
inside. As you issue commands for your subroutine, the "dream" turtle
does its work. When you tell the environment that you're done programming
the subroutine, the though bubble vanishes. Subroutines can call other,
previously-declared subroutines, but that's it. I think that's sufficient,
and I certainly (personally) don't want to go any further.
Here's a demo video:
http://www.youtube.com/watch?v=KK2vjFhiWdg
(click "more info" for details on what's going on)
Here's an earlier demo (which has annotations)
http://www.youtube.com/watch?v=TuLVAQNLXds
(warning: it has a lot more interface glitches ;) )
What do you folks think?