[Newbies] Re: Smalltalk Data Structures and Algorithms
Benjamin L. Russell
DekuDekuplex at Yahoo.com
Mon Jul 27 06:08:09 UTC 2009
To Alan Kay,
Thank you very much for your detailed clarification. I had actually
already started reading your paper  (at
before Richard O'Keefe's response mentioned earlier  (see
hadn't yet had enough time to read through it at that point.
Just for reference, here is how this misunderstanding apparently
1) On the date "Mon, 29 Jun 2009
11:25:34 +0530," K. K. Subramaniam replied to me in the thread "Re:
Re: Smalltalk Data Structures
and Algorithms"  (see
on the squeak-beginners mailing list as follows:
>Concepts in Squeak have their origins in biology rather than in
>computational math. The boundary between 'hardware' and
>'software' is blurry. See the reading list at
>particularly "The Selfish Gene" by Richard Dawkins.
2) On the date "Mon Jul 13 08:35:06 EDT 2009," Bulat Ziganshin wrote
in the thread "[Haskell] 20 years ago"  (see
http://www.haskell.org/pipermail/haskell/2009-July/021487.html) on the
Haskell mailing list as follows:
>Industrial programmers often think that functional programming is
>"unnatural" and cannot be mastered by most of them. But 20 years ago
>they thought the same about OOP
>The first widespead OOP system was a Turbo Pascal 5.5, released 1989.
3) To correct his misunderstanding about which widespread OOP system
came first, I responded as follows  (see
>Just for the record, Turbo Pascal was preceded by a *pure*
>object-oriented language, Smalltalk , as described below:
>>The Smalltalk language, which was developed at Xerox PARC (by Alan Kay
>>and others) in the 1970s, introduced the term object-oriented
>>programming to represent the pervasive use of objects and messages as
>>the basis for computation.... Smalltalk and with it OOP were introduced to
>>a wider audience by the August 1981 issue of Byte magazine.
> "Object-oriented programming - Wikipedia, the free encyclopedia."
>_Wikipedia, the free encyclopedia._ 13 July 2009. 14 July 2009.
4) Ziganshin then replied as follows  (see
>TP was a first OOP system sold in hundreds of thousands of copies. it
>was "OOP for the masses" and its manual reflects what masses thought
>about OOP those times - just the same that they think about FP now.
>you can replace OOP with FP in the manual text i cited and read it as
>modern text :)
5) The discussion continued for a few more posts, until one user then
asked in private e-mail to have the topic moved to the Haskell-Cafe
mailing list. Discussion continued there, with Ketil Malde
re-introducing the topic, as follows 
>[redirected from haskell@]
>Objects contain all kinds of hidden state and dependencies, and the
>sheer unpredicatability of it all is the reason for the
>anthropomorphics - it a symptom of a disease, not a desirable
6) Dissatisfied with his use of the term "disease" in relation to
anthropomorphics, I responded as follows  (see
>Although I don't necessary agree with your choice of the term, I find
>it interesting that you should use the biological term "disease";
>according to a post  entitled "Re: Re: Smalltalk Data Structures
>and Algorithms," by K. K. Subramaniam, dated "Mon, 29 Jun 2009
>11:25:34 +0530," on the squeak-beginners mailing list (see
>>Concepts in Squeak [a dialect and implementation of Smalltalk] have
>>in biology rather than in computational math.... See the reading list at
>>particularly "The Selfish Gene" by Richard Dawkins.
7) This is when Richard O'Keefe entered the thread, claiming that
Subramaniam's above-mentioned post was incorrect, as follows 
>That posting is wrong.
>Smalltalk's roots are very firmly planted in Lisp,
>with perhaps a touch of Logo (which also had its roots in Lisp).
>The classic Smalltalk-76 paper even contains a meta-circular
>interpreter, which I found reminiscent of the old Lisp one.
>The "biological" metaphor in Smalltalk is actually a SOCIAL
>metaphor: sending and receiving messages, and a "social"
>model of agents with memory exchanging messages naturally
>leads to anthropomorphisms.
At this point, I considered responding that Smalltalk was in fact
rooted in biology, so I skimmed your paper  for the term "LISP."
However, I then came across such explanations as the following, which
led me to think that O'Keefe was correct (at the end of section "II.
1967-69--The FLEX Machine, a first attempt at an OOP-based personal
>The biggest hit for me while at SAIL in late '69 was to really
>understand LISP. Of course, every student knew about car, cdr,
>and cons, but Utah was impoverished in that no one there used
>LISP and hence, no one had penetrated thye mysteries of eval and
>apply. I could hardly believe how beautiful and wonderful the idea
>of LISP was [McCarthy 1960]. I say it this way because LISP had not
>only been around enough to get some honest barnacles, but worse,
>there wee deep falws in its logical foundations. By this, I mean that
>the pure language was supposed to be based on functions, but its
>most important components---such as lambda expressions quotes,
>and conds--where not functions at all, and insted ere called special
>forms. Landin and others had been able to get quotes and cons in
>terms of lambda by tricks that were variously clever and useful, but
>the flaw remained in the jewel. In the practical language things
>were better. There were not just EXPRs (which evaluated their
>arguments0, but FEXPRs (which did not). My next questions was,
>why on earth call it a functional language? Why not just base
>everuything on FEXPRs and force evaluation on the receiving side
>when needed? I could never get a good answer, but the question
>was very helpful when it came time to invent Smalltalk, because this
>started a line of thought that said "take the hardest and most
>profound thing you need to do, make it great, an then build every
>easier thing out of it". That was the promise of LiSP and the lure of
>lambda--needed was a better "hardest and most profound" thing.
>Objects should be it.
That paragraph, together with the meta-circular interpreter given in
the appendix, gave me the mistaken impression (at first) that O'Keefe
After reading your response, I then looked through your paper again,
and it seems that you had probably intended to emphasize the following
paragraphs (in the "Introduction"), instead:
>Smalltalk's design--and existence--is due to the insight that
>everything we can describe can be represented by the recursive
>composition of a single kind of behavioral building block that hides
>its combination of state and process inside itself and can be dealt
>with only through the exchange of messages. Philosophically,
>Smalltalk's objects have much in common with the monads of
>Leibniz and the notions of 20th century physics and biology....
>In computer terms, Smalltalk is a recursion on the notion of computer
>itself. Instead of dividing "computer stuff" into things each less strong
>than the whole--like data structures, procedures, and functions which
>are the usual paraphernalia of programming languages--each Smalltalk
>object is a recursion on the entire possibilities of the computer. Thus its
>semantics are a bit like having thousands and thousands of computer all
>hooked together by a very fast network. Questions of concrete
>representation can thus be postponed almost indefinitely because we
>are mainly concerned that the computers behave appropriately, and are
>interested in particular strategies only if the results are off or come back
The difficulty is that the paper, as a whole, deals with influences
from both LISP and biology, and without perusing the paper, it is easy
to get a misconception as to which is the more important influence.
This is most likely what gave O'Keefe the misconception that Smalltalk
was rooted in LISP instead of biology.
-- Benjamin L. Russell
 Kay, Alan C. "The Early History of Smalltalk." Cambridge,
Massachusetts: _History of Programming Languages: The second ACM
SIGPLAN conference on History of programming languages_ (1993): 69-95.
Also available at
 O'Keefe, Richard. "Re: Re: [Haskell] Re: 20 years ago."
gmane.comp.lang.haskell.cafe. Gmane. 16 July 2009. 27 July 2009.
 Subramaniam, K. K. "Re: Re: Smalltalk Data Structures and
Algorithms." The Beginners Archives. Squeak.org. 29 June 2009. 27 July
 Ziganshin, Bulat. "20 years ago." gmane.comp.lang.haskell.general.
Gmane. 13 July 2009. 27 July 2009.
 Russell, Benjamin L. "Re: 20 years ago."
gmane.comp.lang.haskell.general. Gmane. 14 July 2009. 27 July 2009.
 Ziganshin, Bulat. "Re: Re: 20 years ago."
gmane.comp.lang.haskell.general. Gmane. 14 July 2009. 27 July 2009.
 Malde, Ketil. "Re: [Haskell] Re: 20 years ago."
gmane.comp.lang.haskell.cafe. Gmane. 14 July 2009. 27 July 2009.
 Russell, Benjamin L. "Re: [Haskell] Re: 20 years ago."
gmane.comp.lang.haskell.cafe. Gmane. 15 July 2009. 27 July 2009.
On Fri, 24 Jul 2009 07:50:35 -0700 (PDT), Alan Kay
<alan.nemo at yahoo.com> wrote:
>This is an interesting example of an ever increasing web disease -- that is: expressing mere opinions without foundations or checking. This one is easy, because there is a readily available "Early History of Smalltalk" that the ACM got me to write in 1993. So why wouldn't people just type "history of smalltalk" into Google? (I don't know and I haven't been able to figure this out).
>The very first hit finds this paper. (This one is not the best version of it because someone just scanned the doc I wrote to get an HTML version and left out lots of the pictures. But in looking at it, it seems to answer this question very straightforwardly -- and that answer was given by "someone who was actually there" and had a hand in the invention of Smalltalk, rather than people with opinions from the side.)
>What is wrong? Why is mere opinion so dominating discussions held on the easiest medium there has ever been that can provide substantiations with just a little curiosity and work? Is the world completely reverting to an oral culture of assertions held around an electronic campfire?
>As anyone who would be willing to read a few pages of writing will be able to see, there were a number of important influences on the invention of objects and then the invention of Smalltalk itself.
>a. The first two influences I saw were pure mathematics and molecular biology (these were my two majors in college starting in 1958).
>b. The second two I saw (in the very early 60s) were procedural abstractions of date structures in the Burroughs 220 file system for the Air Force, and especially the Burroughs B5000 computer hardware.
>c. "In the air" in the ARPA community in 1966 was the intention to invent a new kind of distributed network with "no central control or switching".
>d. The next two I saw (in 1966 in the very same week) were Sketchpad and Simula. Sketchpad was the dominant metaphor, but I had to see Simula a few days later to understand just how great an idea Sketchpad was.
>These seven influences got me to thinking about one abstraction that was indeed like a biological cell on the one hand and an entire computer on the other which could be universally used at all levels of scales in both software and hardware to "model anything" (including all the old inconvenient things computing was using). This is where "message passing" took hold as something stronger in concept and more loosely coupled and scalable system-wise.
>Somewhat asked me what I was doing and I said "object oriented computing". (I should have thought much harder about the choice of terms)
>a. In 1968 I saw Seymour Papert, Wally Feurzig, et al., and LOGO and got interested in the idea of a computer and computer environment for children. Right around that time I read Marvin Minsky's incredible book "Computation: Finite and Infinite Machines" and he made a kind of Lisp from Goedel numbers that was really beautiful. This got me to look at Lisp again and finally understand what was truly great about it. In 1970 I was at the Stanford AI Project on a postdoc and I started playing around with various kinds of interpreters.
>b. In 1971 at PARC we had the wonderful funding to be able to try to really make all this happen, and I started thinking about a programming language for children that would not be harder to learn than LOGO but which would be object oriented and also use Carl Hewitt's ideas in PLANNER as a way of communicating in forms that could be used for deduction (this was somewhat like the object-oriented Prologs that were done much later).
>c. In 1972, while working on all this "the bet" happened and I spent a few weeks just making the simplest possible OOP language using McCarthy's techniques first employed for Lisp in the late 50s. This is in the Appendix of the "Early History" paper, and it is what Dan Ingalls implemented in a month to get a first running version of Smalltalk.
>I most definitely still think of OOP at its best as being "biological".
>Best wishes (and happy reading)
>> From: Benjamin L. Russell <DekuDekuplex at Yahoo.com>
>> Date: 24. Juli 2009 03:37:04 GMT-03:00
>> To: beginners at lists.squeakfoundation.org
>> Subject: [Newbies] Re: Smalltalk Data Structures and Algorithms
>> Reply-To: "A friendly place to get answers to even the most basic questions about Squeak." <beginners at lists.squeakfoundation.org>
>> On Mon, 29 Jun 2009 11:25:34 +0530, "K. K. Subramaniam"
>> <subbukk at gmail.com> wrote:
>>> Concepts in Squeak have their origins
>>> in biology rather than in computational math. The boundary between 'hardware'
>>> and 'software' is blurry. See the reading list at
>>> particularly "The Selfish Gene" by Richard Dawkins.
>> Richard O'Keefe refutes this claim in his post  "Re: Re: [Haskell]
>> Re: 20 years ago," dated "2009-07-16 01:38:14 GMT," on the
>> Haskell-Cafe mailing list (see
>>>>> Concepts in Squeak [a dialect and implementation of Smalltalk] have
>>>> their origins
>>>>> in biology rather than in computational math....
>>> That posting is wrong.
>>> Smalltalk's roots are very firmly planted in Lisp,
>>> with perhaps a touch of Logo (which also had its roots in Lisp).
>>> The classic Smalltalk-76 paper even contains a meta-circular
>>> interpreter, which I found reminiscent of the old Lisp one.
>>> The "biological" metaphor in Smalltalk is actually a SOCIAL
>>> metaphor: sending and receiving messages, and a "social"
>>> model of agents with memory exchanging messages naturally
>>> leads to anthropomorphisms.
>>> The other classic OO language, which inspired C++, which
>>> inspired Java, which inspired C#, is Simula 67, which has
>>> its roots in Algol 60. While Simula 67 was sometimes used
>>> for simulating biological processes, the main background
>>> was discrete event systems like factories and shops; there
>>> are no biological metaphors in Simula.
>> -- Benjamin L. Russell
>>  O'Keefe, Richard. "Re: Re: [Haskell] Re: 20 years ago."
>> gmane.comp.lang.haskell.cafe. Gmane. 16 July 2009. 24 July 2009.
>> --Benjamin L. Russell / DekuDekuplex at Yahoo dot com
>> Translator/Interpreter / Mobile: +011 81 80-3603-6725
>> "Furuike ya, kawazu tobikomu mizu no oto."
>> -- Matsuo Basho^
>> Beginners mailing list
>> Beginners at lists.squeakfoundation.org
Benjamin L. Russell / DekuDekuplex at Yahoo dot com
Translator/Interpreter / Mobile: +011 81 80-3603-6725
"Furuike ya, kawazu tobikomu mizu no oto."
-- Matsuo Basho^
More information about the Beginners