All the discussion on the "Ship it with Squeak" and "Belling the cat" 
threads has reminded me of my more favorite use for Squeak.

There are at least two uses for programming.  The common one that 
most people optimize for is building applications or other software 
to sell.  The other one is "ad hoc" programming, where you use 
programming for yourself, perhaps for learning or maybe just 
demonstrating ideas (the way people sketch today).  (As people I 
pester on the SqueakAudio list know, my current personal focus is 
learning computer music with Squeak.)  It's not at all clear that 
these are similar kinds of activities or even if you'd want to use 
the same language for both. For the former use, you worry about code 
repositories, adequate documentation of your interfaces, and well 
factored code.  For the latter...Ha!  Who's going to see my code? I'm 
throwing it away as fast as I write it!

More seriously, the issues of how one creates an expressive, 
easy-to-learn, and widely-applicable programming language for the 
latter kind of use are not explored much nowadays.  Those issues used 
to be hot, and programming language experts used to explore different 
languages that helped people in different ways.  Nowadays, efficiency 
and provability seem to have taken over programming language 
conferences, which are much more former-use issues than latter-use 
issues.  Maybe because former-use has more economic benefits than 
latter-use...until you get close.  Then the common-daily-use market 
is MUCH larger than the applications market.

Andy diSessa, a longtime proponent of "Computing Literacy," tells a 
great story about what it takes to make programming really take off 
in the common-daily-use sense in his book "Changing Minds."  Newton's 
intellectual achievement of inventing calculus to demonstrate his 
scientific points about motion was astounding.  But Leibnitz invented 
calculus at about the same time, and it's his notation (the dx/dt 
stuff) that we use today.  Why?  Well, Leibnitz's notation is easier 
to use and it makes expressing some hard theorems almost simple.  But 
does it matter all that much?  It took almost two hundred years for 
Calculus to become commonplace part of the curriculum.  It was in the 
early part of the 1900's that teachers tried to teach Calculus to 
undergrads, and succeeded enough that later classes assumed Calculus 
knowledge: it became infrastructural.  But what if, Andy asks, 
Calculus was 10% harder?  What if it was harder to teach it and 
people were less successful learning it?  Would it have still become 
commonplace?

It's an interesting conjecture, but I'm not sure that I agree with 
it.  Andy is using the story to argue that "Once we get the right 
notation, perhaps programming WILL become commonplace." Yet, it's 
clear that we are hopelessly unsuccessful teaching programming, and 
we still require a great many undergrads to study programming. 
(Everyone at Georgia Tech must take a first course in Scheme.)  The 
fact that we are hopelessly unsuccessful teaching programming is 
quite well supported in research and experience.  Only about 30% of 
the students who come out of a college-level intro to programming 
class know how to write a program to average positive integers, 
avoiding the negative ones until a flag value comes in.  Only about 
50% of the CS majors in their Sophomore year can write that one 
without screwing up the negative or flag test.  (If you're a teacher, 
I challenge you to try this or a similar test on your own students! 
We just did at Tech last year, and we're all still reeling from the 
results.)

The part I completely agree with Andy on is that common programming 
languages are nowhere easy enough to learn yet, and I hope that the 
right notation does lead to common-daily-use.  And while I applaud 
the efforts to come up with a Squeak that's great to write 
applications in (and my group would certainly use and perhaps 
contribute to such an effort), it's the potential for using Squeak 
toward that common-daily-use that I find so intriguing and daunting.

Mark
--------------------------
Mark Guzdial : Georgia Tech : College of Computing : Atlanta, GA 30332-0280
Associate Professor - Learning Sciences & Technologies.
Collaborative Software Lab - http://coweb.cc.gatech.edu/csl/
(404) 894-5618 : Fax (404) 894-0673 : guzdial at cc.gatech.edu
http://www.cc.gatech.edu/gvu/people/Faculty/Mark.Guzdial.html