12 ms·
Soup – Alan Kay on Objects
- dang 8y agoThis 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
- IBCNU 8y ago"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 8y agoI think he's talking about David Reed's work: http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-205.pdf http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-20...
- scroot 8y agoFor anyone reading this, Reed also worked with Kay on Croquet (an interesting project in its own right) which implemented this object-based idea of "time" via a framework called TeaTime [1]. You can try out Croquet for yourself in the latest version of Squeak -- see [2] [1] http://www.wetmachine.com/inventing-the-future/controlling-time-teatime/ http://www.wetmachine.com/inventing-the-future/controlling-t... [2] http://forum.world.st/ANN-Open-Croquet-for-Squeak-5-2-32bit-release-td5087739.html http://forum.world.st/ANN-Open-Croquet-for-Squeak-5-2-32bit-...
- jonahx 8y agoThat link is broken, but archive.org has it: https://web.archive.org/web/20100713132640/http://publications.csail.mit.edu/lcs/pubs/pdf/MIT-LCS-TR-205.pdf https://web.archive.org/web/20100713132640/http://publicatio...
- blihp 8y agoOdd, 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'
- infradig 8y agoIf you dig Can you'll also dig Neu!
- espeed 8y agoSylvan Clebsch's [1] answer to this problem is designed into Pony [2], a high-performance lock free and data-race free actor-model language and runtime [3] based on a novel deny-capabilities model... Deny capabilities for safe, fast actors [pdf]: https://www.doc.ic.ac.uk/~scd/fast-cheap-AGERE.pdf https://www.doc.ic.ac.uk/~scd/fast-cheap-AGERE.pdf Sylvan has since joined MSR Cambridge and is working on the distributed runtime. He's giving a talk at QCon London in March, and there are several talks on YouTube where he discusses the ideas he combined into Pony's design [4]. [1] https://github.com/sylvanc https://github.com/sylvanc [2] https://github.com/ponylang/ponyc https://github.com/ponylang/ponyc [3] https://www.ponylang.io/discover/#what-is-pony https://www.ponylang.io/discover/#what-is-pony [4] https://www.youtube.com/results?search_query=ponylang+sylvan https://www.youtube.com/results?search_query=ponylang+sylvan
- Splines 8y agoThis 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
- jimbokun 8y ago"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.
- beders 8y agoOr any actor-based framework. The less state you share, the better off you are scaling-wise.
- snidane 8y agoI 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 8y agoOcaml 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 8y ago...and no access to multicore processing that's been ubiquitous for over a decade?
- xfer 8y agoYou can use multicores, just make processes.
- 3rdAccount 8y agoThanks for putting this together Michael! I always find your blog posts and magazines to be very interesting (lisp, forth, Clojure)...etc.
- agumonkey 8y agoAllow 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 8y agoSeconded. 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.
- joaorico 8y agoThis is the most complete list of Alan Kay's talks I found: https://tinlizzie.org/IA/index.php/Talks_by_Alan_Kay https://tinlizzie.org/IA/index.php/Talks_by_Alan_Kay
- rgrau 8y agoYoshiki 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
- pjmlp 8y ago
- kuwze 8y agoDoes anyone know why Smalltalk never made the leap to actors?
- jacquesm 8y agoSmalltalk 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 8y agoI’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?
- jacquesm 8y agoSmalltalk-71 perhaps? http://worrydream.com/EarlyHistoryOfSmalltalk/ http://worrydream.com/EarlyHistoryOfSmalltalk/
- ptrott2017 8y agoSmalltalk 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
- jacquesm 8y agoHaven't seen Michael on here for a while. Good stuff.
- fogus 8y agoThanks 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).
- gambler 8y agoThank 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.
- leoc 8y agoReposting 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.)
- rawoke083600 8y agoWith 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"
- espeed 8y agoThis 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
- man-and-laptop 8y agoDoesn'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 8y agoI 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
- tonyg 8y agoWhere is the state? What changes in response to the send? Here, it'd be the cheese, so it'd make sense to have the cheese be the receiver; but a real answer comes from moving further toward the Actor perspective. Given a distributed system with message passing, how do you choose to allocate locations to items of mutable state? That choice gives you your answer. All single-receiver systems have a problem when faced with multiple otherwise-independent pieces of state that have to change in response to a given combination. You end up encoding various kinds of transaction to keep every member of the group on the same page. Multiple-dispatch systems don't have that problem, but the tradeoff is that they're no longer message passing: all the "recipients" of a "message" live logically in the "same" location for the purposes of handling a given invocation, and if they're actually physically separated, the language implementer has to do the job of providing the illusion (e.g. via transactions) that they're in the same place.
- eadmund 8y ago
- deleted 8y ago[deleted]
- da02 8y agoA 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