
Soup – Alan Kay on Objects - grzm
http://blog.fogus.me/2018/10/25/soup/
======
agumonkey
Allow me one suggestion about Kay, it seems the man knows way too much to be
understood by the average us. Not pompously, it's just that when he means A we
read B. That led to the drift between Smalltalk OO and cpp OO. I thought it
was exagerated, but smalltalk is really entirely different from cpp/java. It
has the same vocabulary, but the reality is quite surprising.

Kay had education in abstract algebra, cell biology(apparently).. he was fond
of old varied computing arch (burroughs). So my point is, before reading his
text, do yourself a favor, dig in the litterature deeply and broadly.

~~~
gambler
Seconded.

Took me about 5 long videos and some Google searches to get into his frame of
reference, but it was well worth it. The amount of useful ideas I got out of
his talks is absolutely astounding. He really changed the way I think about
programming, computing, user interfaces and complex system design.

I am slowly watching through all of the videos from Kay I can find.

A good compilation to start with:
[http://vpri.org/talks.htm](http://vpri.org/talks.htm)

You can also search Vimeo for more.

~~~
rgrau
Yoshiki Ohshima regularly posts interesting "new" videos on his youtube
channel[1]. Not only Alan Kay's talks but content produced in PARC back in the
day, or relevant people around that environment.

If you need a less abstract teaser before getting into the talks and
"philosophy" part of the game, here's a demo of something called "Alternate
Reality Kit"[2] back in 1986. Brace yourselves.

1\.
[https://www.youtube.com/user/yoshikiohshima](https://www.youtube.com/user/yoshikiohshima)

2\.
[https://www.youtube.com/watch?v=I9LZ6TnSP40](https://www.youtube.com/watch?v=I9LZ6TnSP40)

------
jimbokun
"The big deal was encapsulation and messaging to provide loose couplings that
would work under extreme scaling (in manners reminiscent of Biology and
Ecology)."

This describes exactly why Erlang scales so well.

~~~
snidane
I always tried to decipher Alan Kay's notion of object oriented programming.

Erlang with its active objects seems to me to fit precisely his description.
Active objects = the objects themselves decide when to run a method = receive
a message and react to it.

As opposed to java like oop where the objects just sit there passively and are
woken up in a blocking fashion by callers from outside.

It appears to me that c++/java etc. flavour of oop uses objects just as a
module system, but then has another module/namespace/package mechanism besides
that. Two concepts for the same thing essentially, just making the language
unnecessarily complicated.

~~~
andrepd
Ocaml has both! You have a (very powerful) module system, serving purposes of
encapsulation and namespacing, and other more powerful abstractions, and you
also have dynamic/message-passing style OOP available to you.

~~~
jjtheblunt
...and no access to multicore processing that's been ubiquitous for over a
decade?

~~~
icc97
I was quite amazed that this wasn't the case. OCaml clearly is working on it -
[http://ocamllabs.io/doc/multicore.html](http://ocamllabs.io/doc/multicore.html)

Plus there are monadic ways of handling concurrency with lwt.

------
Splines
This is in the comments of the post but the author should really have linked
to Alan Kay's comments here:

[https://news.ycombinator.com/item?id=11808551](https://news.ycombinator.com/item?id=11808551)

~~~
fogus
Fixed now. Thanks!

------
IBCNU
"For a variety of reasons — none of them very good — this way of being safe
lost out in the 60s in favor of allowing race conditions in imperative
programming and then trying to protect against them using terrible semaphores,
etc which can lead to lock ups." \- it would be great for you to lay those
out! Also please tell us other Krautrock songs you dig!

~~~
blihp
I _think_ he's talking about David Reed's work:
[http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-
TR-20...](http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-205.pdf)

~~~
jonahx
That link is broken, but archive.org has it:

[https://web.archive.org/web/20100713132640/http://publicatio...](https://web.archive.org/web/20100713132640/http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-
LCS-TR-205.pdf)

~~~
blihp
Odd, it worked for me yesterday. I wonder if someone noticed a traffic spike
on that URL and said 'hmm, that/those page(s) shouldn't still be there'

------
dang
This is lovely. There are amazing riches in Alan's comment history on HN, for
anyone who wants to dive into it:
[https://news.ycombinator.com/threads?id=alankay1](https://news.ycombinator.com/threads?id=alankay1)

------
leoc
Reposting my comment from discussion
[https://news.ycombinator.com/item?id=14318663](https://news.ycombinator.com/item?id=14318663)
with a fixed YouTube link:

> Now this right here
> [https://www.youtube.com/watch?v=NdSD07U5uBs&t=1362](https://www.youtube.com/watch?v=NdSD07U5uBs&t=1362)
> is the problem: if you follow the idea of computers as virtualisers where it
> leads you do _not_ , in the general case, end up with the flat backplane
> talked about from 23:15 and shown in the accompanying slide. (Actually, this
> is in turn probably just a symptom of another, more general problem.)

------
3rdAccount
Thanks for putting this together Michael! I always find your blog posts and
magazines to be very interesting (lisp, forth, Clojure)...etc.

------
gambler
Thank you for compiling this! All of the ideas in the text are incredibly
powerful and important, but they are buried under megabytes of OOP trivia
centering around C++ and Java.

I think at some point I will try to write an article "translating" his OOP
ideas to something Java/C#/JS programmers can readily understand.

------
jacquesm
Haven't seen Michael on here for a while. Good stuff.

~~~
fogus
Thanks for the sentiment. The post is meant as a "living document" and will be
updated with links and footnotes from now until I die (even if it kills me).

------
espeed
_This created a simple temporal logic, with a visualization of “collections of
facts” as stacked “layers” of world-lines. This can easily be generalized to
world-lines of “variables”, “data”, “objects” etc. From the individual point
of view “values” are replaced by “histories” of values..._

Connect this idea with Conal Elliott's recently posted paper/talk on "The
Simple Essence of Automatic Differentiation":
[https://news.ycombinator.com/item?id=18306860](https://news.ycombinator.com/item?id=18306860)

------
kuwze
Does anyone know why Smalltalk never made the leap to actors?

~~~
jacquesm
Smalltalk did not implement the message passing at the lowest level as an
actual message between processes. It predates the actor model (which was
inspired by it), which operates at a somewhat higher level than Smalltalk
'messages' do.

Smalltalk at the lower levels is a lot of very elegant hacks to give an
outward appearance of one mechanism while being implemented in a very
different manner. That is also one of the main reasons why it works as a VM,
the kind of functionality required to detect the primitives at speed so that
functions can be called that do the real work is hard to implement natively in
a way that it is still efficient.

The top levels of Smalltalk are as elegant and simple as LISP, but under the
hood Smalltalk is decidedly less elegant to make it work on the hardware
available at the time.

Of course none of that stops you from implementing the Actor concepts at a
higher level than Smalltalk objects and there were (are?) some efforts to do
just that.

~~~
fiddlerwoaroof
I’m no expert, but didn’t Carl Hewitt’s work on Actors (1973) predate
smalltalk by seven years or so? Or was there smalltalk before smalltalk-80?

~~~
ptrott2017
Smalltalk started in 1969 or so with first release inside Xerox Parc was in
1972 (Smalltalk-72). See early history of smalltalk :
[http://wiki.c2.com/?EarlyHistoryOfSmalltalk](http://wiki.c2.com/?EarlyHistoryOfSmalltalk)

See Carl Hewitt's retrospective on Actors which he attributes inspiration to
Smalltalk, simula and lisp here:
[https://arxiv.org/vc/arxiv/papers/1008/1008.1459v8.pdf](https://arxiv.org/vc/arxiv/papers/1008/1008.1459v8.pdf)

~~~
tonyg
Yes, exactly; also, there's an acknowledgement of the influence of "SMALL
TALK" at the end of Hewitt, Bishop & Steiger's original 1973 IJCAI paper as it
appeared in print ([https://eighty-twenty.org/2016/10/12/hewitt-bishop-
steiger-i...](https://eighty-twenty.org/2016/10/12/hewitt-bishop-steiger-
ijcai-1973)).

Actors, Smalltalk, Monitors and CSP all co-evolved during the 1970s, with many
of the principals visiting each other and exchanging ideas. Retrospectives
like Brinch Hansen's
([https://dl.acm.org/citation.cfm?id=155361](https://dl.acm.org/citation.cfm?id=155361))
spell out some of the lines of influence.

~~~
fiddlerwoaroof
Thanks, TIL

------
man-and-laptop
Doesn't OOP have the ontological problem:

Does the knife cut the cheese, or does the cheese get cut by the knife?
Formally: Is it knife.cut(cheese) or cheese.getCutBy(knife)? And why is the
first argument (knife in the first instance or cheese in the second) special?
Maybe Alan Kay means something different and less overtly flawed when he talks
about OOP.

~~~
mercer
I could be entirely off here, but it seems to me this problem is less present
when you send messages instead of call methods.

From the perspective of sending messages, the solution is that the knife
object/actor sends a message to the cheese object/actor that it wants to cut
it. the cheese can then respond to that message by changing its state to
'cut', or perhaps by sending a message back to the knife that it's not sharp
enough for this particular chunk of cheese, and that the cheese remains in an
uncut state. The knife actor/object could then decide to break, or sharpen
itself, or whatever.

I haven't given this much thought yet though, so I'd love to hear how I'm all
wrong about this!

EDIT: I guess this comment says something similar:
[https://news.ycombinator.com/item?id=18333652](https://news.ycombinator.com/item?id=18333652)

------
da02
A list of Alan Kay talks:

* [http://alan-kay.wikia.com/wiki/Alan_Kay_Wiki](http://alan-kay.wikia.com/wiki/Alan_Kay_Wiki)

* [https://tinlizzie.org/IA/index.php/Talks_by_Alan_Kay](https://tinlizzie.org/IA/index.php/Talks_by_Alan_Kay)

------
rawoke083600
With the "(C++/Java)-style" OOP on one side and the more pure/old styles of
SmallTalk/(and later actors) I do want to mention that I like the Go-Lang
model's version of "OOP" its sorta C with "just-enough-OOP-lookalike-stuff"

