Re: [CAG] Re: [fonc] Fexpr the Ultimate Lambda

2011-11-26 Thread Alan Kay
Hi Carl

Yes, I have always felt that you got nowhere near the coverage and recognition 
you deserved for PLANNER (the whole enchilada) -- to me it was a real landmark 
of a set of very powerful insights and perspectives. Definitely one of the very 
top gems of the late 60s!


I recall there was lots of good wine at that Pajaro Dunes meeting! (And Jeff 
Rulifson helped me pull off that Beef Wellington with the three must have 
sauces). That was also a great group. Cordell Green was there, Richard 
Waldinger, Rulifson, (Bob Yates?), Bob Balzer, etc. Can you remember any of the 
others? That one must have been in 1970.

And it was indeed the second -- and sequential -- evaluator (from the Lisp 
1.5 manual) that I had in mind when I did the ST-72 eval. Another influence on 
that scheme was the tiny Meta II parser-compiler that Val Shorre did at UCLA in 
1963 (for an 8K byte 1401!). I loved that little system. This led to the ST-72 
eval really being a kind of cascaded apply ...


And there's no question that once 
you aim at real objects a distributed eval makes great sense.
Cheers,

Alan






 From: Carl Hewitt hew...@concurrency.biz
To: Alan Kay alan.n...@yahoo.com 
Cc: Programming Language Design pi...@googlegroups.com; Dale Schumacher 
dale.schumac...@gmail.com; The Friday Morning Applied Complexity Coffee 
Group fr...@redfish.com; computational-actors-gu...@googlegroups.com 
computational-actors-gu...@googlegroups.com; Fundamentals of New Computing 
fonc@vpri.org 
Sent: Saturday, November 26, 2011 9:24 AM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 

Hi Alan,
 
Yes, Smalltalk-71 had lots of potential!  Unfortunately, the way it developed 
was that Kowalski picked up a subset of micro-Planner (backward chaining only 
along with backtracking only control structure) and PROLOG was made into 
something of an ideology.  I have published a history in ArXiv titled “Middle 
History of Logic Programming: Resolution, Planner, Edinburgh LCF, Prolog, and 
the Japanese Fifth Generation Project” at
http://arxiv.org/abs/0904.3036
 
I have fond memories of the Beef Wellington that you prepared at one of the 
Pajaro Dunes meetings of the “DARPA Junior Over-achievers” society!  Before 
McCarthy developed his meta-circular definition, the developers of Lisp 1 took 
a similar approach to yours by developing a looped sequential program that 
mimicked their assembly language implementation.
 
Using “eval” as a message instead of the Lisp procedure is an interesting way 
to do language extension. For example lambda notation could be added to 
ActorScript as follows:


”lambda” “(“ id|-Identifier “)” body|-Expression   ~~   eval(env) -- 
(argument) -- body.eval(Environment(id,argument, env))
 
  where 
 
   Environment(iden, value, enviro)   ~~   lookup(iden2) -- 
iden2=iden ?~ true -- value ?? false -- enviro.lookup(iden2) ~?
 
Cheers,
Carl
 
From:Alan Kay [mailto:alan.n...@yahoo.com] 
Sent: Friday, November 25, 2011 15:37
To: Carl Hewitt; Dale Schumacher
Cc: Programming Language Design; The Friday Morning Applied Complexity Coffee 
Group; computational-actors-gu...@googlegroups.com; Fundamentals of New 
Computing
Subject: Re: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Hi Carl
 
I've always wished that we had gotten around to doing Smalltalk-71 -- which in 
many ways was a more interesting approach because it was heavily influenced by 
Planner -- kind of a Planner Logo with objects -- it was more aimed at the 
child users we were thinking about. ST-72 did the job at a more primitive 
level.
 
P.S. The characterizations of ST-71 and ST-72 in your paper are not quite 
accurate  -- but this doesn't matter -- but it is certainly true that we did 
not put concurrency in at the lowest level, nor did we have a truly formal 
model (I wrote the first interpreter scheme using a McCarthy-like approach -- 
it was a short one-pager -- but I wrote it as a looped sequential program 
rather than metacircularly because I wanted to show how it could be 
implemented).
 
Cheers,
 
Alan
 
 



From:Carl Hewitt hew...@concurrency.biz
To: Dale Schumacher dale.schumac...@gmail.com 
Cc: Programming Language Design pi...@googlegroups.com; The Friday Morning 
Applied Complexity Coffee Group fr...@redfish.com; 
computational-actors-gu...@googlegroups.com 
computational-actors-gu...@googlegroups.com; Alan Kay 
alan.n...@yahoo.com; Fundamentals of New Computing fonc@vpri.org 
Sent: Friday, November 25, 2011 12:11 PM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
I have started a discussion topic on Lambda the Ultimate so that others can 
participate here:  Actors all the way down
 
How SmallTalk-72 influenced the development of Actors is discussed in Actor 
Model of Computation: Scalable Robust Information Systems.
 
Cheers,
Carl
 
PS. Kristen Nygaard and I had some fascinating late night discussions over 
such matters in Aarhus lubricated with Linie

Re: [CAG] Re: [fonc] Fexpr the Ultimate Lambda

2011-11-25 Thread Alan Kay
Hi Carl

I've always wished that we had gotten around to doing Smalltalk-71 -- which in 
many ways was a more interesting approach because it was heavily influenced by 
Planner -- kind of a Planner Logo with objects -- it was more aimed at the 
child users we were thinking about. ST-72 did the job at a more primitive level.

P.S. The characterizations of ST-71 and ST-72 in your paper are not quite 
accurate  -- but this doesn't matter -- but it is certainly true that we did 
not put concurrency in at the lowest level, nor did we have a truly formal 
model (I wrote the first interpreter scheme using a McCarthy-like approach -- 
it was a short one-pager -- but I wrote it as a looped sequential program 
rather than metacircularly because I wanted to show how it could be 
implemented).

Cheers,

Alan





 From: Carl Hewitt hew...@concurrency.biz
To: Dale Schumacher dale.schumac...@gmail.com 
Cc: Programming Language Design pi...@googlegroups.com; The Friday Morning 
Applied Complexity Coffee Group fr...@redfish.com; 
computational-actors-gu...@googlegroups.com 
computational-actors-gu...@googlegroups.com; Alan Kay alan.n...@yahoo.com; 
Fundamentals of New Computing fonc@vpri.org 
Sent: Friday, November 25, 2011 12:11 PM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 

I have started a discussion topic on Lambda the Ultimate so that others can 
participate here:  Actors all the way down
 
How SmallTalk-72 influenced the development of Actors is discussed in Actor 
Model of Computation: Scalable Robust Information Systems.
 
Cheers,
Carl
 
PS. Kristen Nygaard and I had some fascinating late night discussions over 
such matters in Aarhus lubricated with Linie aquavit :-)   I miss him dearly 
:-(
 
-Original Message-
From: computational-actors-gu...@googlegroups.com 
[mailto:computational-actors-gu...@googlegroups.com] On Behalf Of Dale 
Schumacher
Sent: Friday, November 25, 2011 11:54
To: Alan Kay; Fundamentals of New Computing
Cc: CAG; Programming Language Design; The Friday Morning Applied Complexity 
Coffee Group
Subject: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Yes, absolutely!  I've read that paper numerous times.  Unfortunately, I 
wasn't able to cite all of the branches of the LISP family tree.
 
I _did_ cite Piumarta's work on Maru.  His extensible base is much smaller 
Shutt's, but Kernel provided a better illustration of actor-based evaluation 
techniques.
 
On Fri, Nov 25, 2011 at 1:19 PM, Alan Kay alan.n...@yahoo.com wrote:
 Hi Dale
 Check out The Early History of Smalltalk to see the same insight 
 about Lisp and how it was used to think about and define and implement 
 Smalltalk-72.
 Cheers,
 Alan
  
 
 From: Dale Schumacher dale.schumac...@gmail.com
 To: Fundamentals of New Computing fonc@vpri.org; CAG 
 computational-actors-gu...@googlegroups.com; Programming Language 
 Design pi...@googlegroups.com; The Friday Morning Applied Complexity 
 Coffee Group fr...@redfish.com
 Sent: Friday, November 25, 2011 10:05 AM
 Subject: [fonc] Fexpr the Ultimate Lambda
  
 Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on 
 evaluation, in honor of John McCarthy.
  
 John Shutt’s Kernel language, and its underlying Vau-calculus, is a 
 simplified reformulation of the foundations of the LISP/Scheme family 
 of languages. It is based on the notion that evaluation should be 
 explicit, patterned after Fexprs, rather than implicit, using Lambda.
 The results is a powerful well-behaved platform for building 
 extensible languages. Not extensible in syntax, but in semantics. We 
 have implemented the key mechanisms of Vau-calculus using actors. The 
 actor-based evaluation strategy introduces inherent concurrency 
 prevasively throughout the evaluation process.
  
 ___
 fonc mailing list
 fonc@vpri.org
 http://vpri.org/mailman/listinfo/fonc
  
  
  
 ___
 fonc mailing list
 fonc@vpri.org
 http://vpri.org/mailman/listinfo/fonc
  
  
 
--
You received this message because you are subscribed to the Google Groups 
Computational Actor's Guild group.
To post to this group, send email to 
computational-actors-gu...@googlegroups.com.
To unsubscribe from this group, send email to 
computational-actors-guild+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/computational-actors-guild?hl=en.
 

___
fonc mailing list
fonc@vpri.org
http://vpri.org/mailman/listinfo/fonc