Marcel --

At 1:07 PM +0200 10/13/01, Marcel Weiher wrote:
>On Friday, October 12, 2001, at 02:43 PM, Alan Kay wrote:
>
>>      The main source of outside ideas was Dave Fisher's thesis (A 
>>Control Definition Language CMU 1970). This was not object-oriented 
>>(but I found it to be the logical complement to my thesis of the 
>>very same period) and Dave had cast it in terms of a McCarthy-like 
>>eval in itself, so it was very understandable. It had most of the 
>>things we've always wanted in messaging systems.
>
>I obtained this particular thesis from CMU a while ago, and am still 
>somewhat unclear as to what in particular you are refering to.  The 
>only thing I can think of is the "multiple sequential control" 
>section.

It's how you do the "collision" of themes that makes it profound. 
E.g., Smalltalk-72 was one of the possible reconciliations of the 
object stuff I had been doing with the LISP metabasis. Dave Fisher's 
stuff is not object-oriented but it is a very good way of thinking 
about the problems of control and how they interact with problems of 
environment. Once you say "I want to send messages between objects", 
then Dave's way of dealing with control problems (and especially the 
control relationships he can define) start to become profound. In 
particular, you get nice solutions to all of the relationships that 
arise when you really want to send messages that are more complex 
than simple calls.

>
>>      I think after Carl heard about Smalltalk in Nov 72, and saw 
>>some of the examples, he was able to come up with some valuable 
>>characterizations of control structures and objects. Unfortunately 
>>for posterity, neither the PARC group or the MIT group really was 
>>able to implement a practical enough version of the deeper scope of 
>>these ideas. (Part of the problem is that something like 
>>zero-overhead, large number of processes are needed to really do 
>>the job.)
>
>Are these characterizations in the 77 paper?  (Yet another one to 
>hunt down...)

Most of the Hewitt Actor papers are really worth reading -- as are 
the preceeding PLANNER papers (from which I adapted many ideas for 
Smalltalk-71, which we never got around to implementing). I agree 
very much with Ken Kahn (and have agreed with him for many years), 
that what we need is a more intentional and strategic form of 
programming.
      Carl Hewitt has never gotten the credit he deserved for being a 
pioneer in this form of programming (with PLANNER). If you combine 
this style with objects -- If you really make object-methods goal 
satisfiers, etc., then you get into a much better place for 
programming in general. This was what ST-71 was all about. We always 
encourage Smalltalkers to program as if they are satisfying goals 
with methods, but this is kind of weak tea without extensive language 
support.
      Ken has done a number of languages over the years that have 
shown many interesting insights about this way to program. One of 
them was a language called VULCAN -- and there are several good 
papers that he wrote about these languages (maybe we can get him to 
give us URLs if they are online).

>
>>Recently Andreas Raab has done some remarkable experiments with 
>>very large numbers of very low overhead processes in Squeak which 
>>bodes well for the future.
>
>I am still not quite sure for what specific problems large numbers 
>of processes are a good solution.  Computing propagation patterns 
>on-the-fly and interleaved with the computation carried out by the 
>message payload may be one case, but many/most practical cases seem 
>to be solvable without the need for concurrency.

It's not so much about concurrency as about environments. And it's 
not so much about solution as realization.

Cheers,

Alan
--