The image comes from my replication of the Drive A Car tutorial from the squeakland website. You make a car and then write a script to make it move. Then add a steering wheel and modify the script to control the steering. The blue lines on the diagram originate from the pen down option, so I can see the path made by the car.
Late binding in EToys (Squeak) blows me away.
Variables and their values can be altered while an animation is running in front of you!! This has enormous educational implications in the teaching of important maths concepts.
The commentary in the Drive a Car tutorial is very valuable as well, particularly the points about:
- the value of allowing children to play with icons while gradually and subliminally gaining fluency and appreciation of the power of symbols (described as the "Montessori game")
- the relationship between play of this type and real mathematics: "It is our job to make lots of little aha's happpen during the play, not to disrupt the play. We are not trying to teach them specific math at this point, but how to be real mathematicians. The children have to play with math to do this."
Then, after listening to Alan Kay's 2003 ETech presentation, I become annoyed that something so educationally valuable that was invented decades ago in LISP and SmallTalk has been denied to generations of children.
For a video of Alan Kay doing this go to this page, scroll 2/3rds of the way down the page and download the video titled Kid Program (Med-res - 57 MB)
Alan Kay explains how late binding is also valuable for experienced programmers:
EToys software is being distributed on the OLPC. Information and picture gallery
Most software is made by programmers creating text files that are fed to a compiler and loader which makes a runable program. One can tell how early- or late-bound a system is by looking at the things that can be changed while the program is running. For example, it is generally true of C based systems that most changes in the program have to be done by going back to the text files, changing them, and recompiling and loading them. This is even true of Java. Organizationally, this often leads to at most one or two system builds a day before most bugs can be found.
A late-bound system like LISP or Smalltalk can change pretty much everything while it is running -- in fact, both these systems are so good at this that their development systems are written in themselves and are active during runtime. For example, a program change in Smalltalk takes less than a second to take effect, thus many more bugs can be run down and fixed.
But late-bound has some deeper and more profound properties that include abilities to actually change the both the structure and metastructure of the language itself. Thus an important new idea can be assimilated into the constantly evolving process that is the system.
Another aspect of late-binding is the ability to change one's mind about already instantiated structures that are already doing work. These can be changed automatically on the fly without harming the work they are already doing.
Etc. Wheels within wheels.These ideas are not new, but they are quite foreign and out of the scope of the way most programming is done today