Alan Kay <Alan.Kay at disney.com> wrote:

> Actually, this would be a very good time for suggestions, as we are
> close to trying a whole bunch of "scripting syntax" experiments.

Hi all,
I do research in user programming (I would like to stay away from the 
label "end-user" since users can create software for other users).  
I joined this list a week ago.

I was about to write and ask where to find the tile-based programming 
environment, but I discovered that it is right there in the morphic world! 
It was fun to use, the feedback when placing tiles is very nice, and the 
"is over color" test opens up for a lot of creative uses. Would be useful
to have a collide test too, to be able to handle sprite collisions. Maybe
it is in there already, only I have not found it.

My current work is focused on a field study of children's programming 
of social agents (10-11 year olds). I am exploring the visual language of 
comics as a program representation. Comics are interesting with
respect to programming, because they represent something dynamic in
a concrete static form. The computation model I am currently experimenting
with is inspired by concurrent constraint programming. Each guarded clause 
is represented by a comic strip where the first frame is the guard and the 
successive frames are the body. I call the comic strip representation 
"Concurrent Comics" since the comic strips are not read in sequence, but are 
concurrent events. This is similar to concurrently running scripts in a
morphic 
world. The strips are similar to rules in StageCast (KidSim), but there is no
grid and the agents/processes have a local state rather than a shared global
state. A major source of inspiration is ToonTalk (by Ken Kahn). ToonTalk 
uses an animated program representation based on cartoon characters. While 
using an animated source code is very innovative, a static representation can 
be useful for providing an overview and it is also easier to edit. Part of the
work I am doing right now is comparing the animated representation with 
a comic strip representation. A number of working papers are available at: 
http://www.ida.liu.se/~mikki/comics/ (the quality varies!).
A few pictures and screenshots from the field studies are available at:
http://www.ida.liu.se/~mikki/comics/pictures.html

Have you looked into using comic strip representations in the Squeak
children's programming environment? I recently re-read a paper from
OOPSLA89 by Jay Fenton and Kent Beck which has an example of a
"DynaComicBook" where fish hide from a shark. I wrote Kent Beck
and asked what had become of that idea and he replied that nothing had
happened with it. This should be worth looking into. I believe that comics 
have a great potential as a program representation since it is possibly the 
static representation that best reflects dynamic behaviour. What I have 
found so far in the field studies is that children frequently come up with 
narrative explanations when asked to describe how a program works. The 
narrative thinking can sometimes be a disadvantage, since they find it hard 
to understand that the events described in the comic strips can happen in 
any order, not just in the fixed sequence in which they are defined.
Possibly, 
the use of comics reinforce narrative interpretations. 

In another message Alan Kay <Alan.Kay at disney.com> wrote:

> One of the tricks here is to get away from thinking that programs have 
> to be composed with only a simple text editor.
>      For the last several years we have been experimenting with children 
> doing "tile programming" (as in the current etoy authoring in Squeak). The 

Are there any reports or other documents that describe the results from
these experiments? Are there any etoys available to play with?

> idea here is that the system only lets you construct syntactically correct 
> programs. If this works, then the syntax can be as readable as one wishes. 
> This is an old idea, and the problems with this approach over the years 
> have been awkwardness, fatigue and distraction while trying to think 
> through how the program should work.
>      Almost by accident this time around, we took phrases derived from 
> message headings (with sample values inserted in the parameters as
defaults) 
> as the basic building block. With some sweet work by SqC the act of picking 
> up tile phrases and dropping them in scripts became a pleasant (even
somewhat 
> sensual) act, and we (I was anyway) quite surprised in extensive testing
with 
> children that a far far larger percentage of them became extremely
motivated 
> creators and programmers in this system than in 25 years of previous
experience. 
> (There were a few other factors operating here as well that contributed
to the 
> success of these experiments.)

It would be interesting to hear more about what aspects were surprising 
and which factors contributed to the success. How large part of the
success did the tiling system have versus the other factors? Would also be
interesting to here how these recent experiences with the children differs
from the early experiments with kids using Smalltalk-72.

Are the programs created by the children available?

> 
> We realized that it would be really neat to be able to make something
similar 
> work with Squeak in general, and that an interesting way to approach a
readable 
> yet highly learnable enduser (we call them "omniusers") syntax would be
exhibit 
> programs in a highly readable syntax and that editing and composing would
be 
> mediated by generalizations of the UI techniques that had worked with the
children.
>      Quite a bit has been accomplished over the last six months, and we
will 
> shortly release the first version of this authoring system for the
critiques 
> of the Squeak List.

Would be great to try this. 

Strangely, you do not see work on user programming very often any more. For 
instance, last CHI had no paper on this subject. Good to see that the Squeak 
community seems to take such a big interest in this.

Best, Micke

Mikael Kindborg
Linköping University, Sweden