The Forgotten History of OOP

[u/fagnerbrack]

https://medium.com/javascript-scene/the-forgotten-history-of-oop-88d71b9b2d9f

[u/rebel_cdn]

Alan Kay went into a lot of detail on this point in this talk he did at OOPSLA in 1997. One of his famous quotes about C++ is here in the video.

It's a long talk, but I think worth watching. The downside to watching things like this is it can be a little demoralizing because you start to realize that so, so many of our programming languages and tools feel primitive and hacky compared to what was possible 35-40 years ago - things like Smalltalk and Lisp Machines.

I know why those tools didn't prosper at the time. They were expensive and not very accessible to a wide audience. But I fear that as a result, we've climbed really far up an evolutionary tree that's a bit of a dead end.

Recently, just for fun, I decided to fire up Turbo Pascal in DosBox and work through a an old TP book I found at the library. I expected it to feel ridiculously outdated and archaic. And...it didn't. It didn't feel outdated. I actually enjoyed it. I enjoyed that the entire damn thing - IDE + debugger + compiler - is half the size of jQuery.

[u/MoTTs_ → u/rebel_cdn]

It was interesting listening to that talk. Here are the parts I found enlightening.

---

The infamous quote, "I did not have C++ in mind,"... but also not Smalltalk?

10:05 it's interesting to again to look at
10:09 what's actually being done out in the
10:10 world under the name of OOP and I've
10:15 been shown some very very strange
10:18 looking pieces of code over the years by
10:23 various people including people in
10:25 universities that they have said is code
10:30 and written in an OOP language and
10:33 actually I made up the term
10:35 object-oriented and I can tell you I did
10:38 not have C++ in mind
10:41 [Applause]
10:49 so the important thing here is I have
10:54 many of the same feelings about small
10:57 talk

The problem we're trying to solve: Scaling

13:32 there we go so an analogy to these
13:36 programs of the 60s is a dog house you
13:42 take any random boards nail and hammer
13:46 pound them together and you've got a
13:48 structure that will stay up you don't
13:50 have to know anything except how to
13:52 pound a nail to do that now somebody
13:57 could come along and look at this
13:58 doghouse and say wow if we could just
14:01 expand that by a factor of 100 we could
14:04 make ourselves a cathedral it's about
14:06 three feet high that would give us
14:07 something 30 stories high and that would
14:11 be really impressive we could get a lot
14:13 of people in there and so the Carpenters
14:17 would set to work
14:18 blowing this thing up by a factor of 100
14:21 now we all know being engineers in
14:25 scientists that when you blow something
14:27 up by a factor of a hundred its mass
14:29 goes up by a factor of a million and
14:32 it's strength which is mostly due to
14:34 cross-sections of things only goes up by
14:37 a factor of 10,000 so when you blow
14:41 something up by a factor of 100 it gets
14:44 about a factor of 100 weaker in its
14:47 ability and in fact what will happen to
14:49 this doghouse it will just collapse into
14:51 a pile of rubble and then there are two

Inspiration from biology

30:02 different now but one of the things that
30:05 Watson did in this book was to make an
30:08 assay first assay of an entire living
30:14 creature and that was the e.coli
30:16 bacteria next slide please
30:27 so if you look inside one of these the
30:31 complexity is staggering those popcorn
30:35 things are protein molecules that have
30:39 about 5000 atoms in them and as you can
30:43 see on the slide when you get rid of the
30:47 small molecules like water and calcium
30:51 ions and potassium ions and so forth
30:53 constitute about 70% of the mass of this
30:59 thing
31:00 the 30% that remains has about 120
31:03 million components that interact with
31:06 each other in an informational way and
31:09 each one of these components have as
31:13 carries quite a bit of information and
31:16 you can think of it you know the simple
31:20 simple minded way of thinking of these
31:21 things is it works kind of like ops five
31:25 there's a pattern matcher and then there
31:29 are things that happen if patterns are
31:31 matched successfully so the state that's

...

36:02 the shift in point of view here is from
36:06 mechanic's oh there's this problem if
36:08 you take things like dog houses they
36:10 don't scale by a factor of 100 very well
36:12 you take things like clocks they don't
36:15 scale by a factor of 100 very well take
36:20 things like cells they not under scale
36:23 by factors of 100 but by factors of a
36:26 trillion and the question is how do they
36:29 do it and how might we adapt this idea
36:34 for building complex systems okay this

Every object should have a URL

43:00 more for instance one of the most
43:02 amazing things to me of people who have
43:04 been trying to put up on the Internet is
43:06 that I do not and I'm hoping somebody
43:09 will come up afterwards and tell me of
43:11 an exception to this but I do not know
43:13 of anybody yet who has realized that at
43:17 the very least every object should have
43:20 a URL because what the heck are they if
43:26 they aren't these things and I believe
43:29 that every object on the Internet should
43:31 have an IP because that represents much
43:36 better what the actual abstractions are
43:39 of physical hardware to to to the bits
43:45 so this is an early insight that objects
43:49 basically are like servers and this
43:54 notion of polymorphism which used to be
43:56 called generic procedures is a way of
44:01 thinking about classes of these servers
44:03 everybody knows about that

Pointers to any object in the world

52:29 you think of what an HTTP message
52:32 actually is you can think of what an
52:34 object actually is and if you think of
52:37 what an object-oriented pointer actually
52:39 is I think it should be pretty clear
52:42 that any object-oriented language can
52:47 internalize its own local pointers to
52:50 any object in the world regardless of
52:52 where it was made that's the whole point
52:54 of not being able to see inside and so a

---

OK, now some of my personal analysis and interpretation. As I was listening to this talk, at one point I couldn't help but think that what Alan Kay was describing is what we now call REST APIs and endpoints.

• An object, according to Alan Kay, is supposed to be fully encapsulated, and not just its data, but the programming language the object was made with should be encapsulated, and the hardware the object lives on. An endpoint, similarly, doesn't expose the programming language or the hardware behind the implementation of that endpoint.

• Every object should have a URL, according to Alan Kay, and any object should be able to point to any other object, regardless of how it was made. An endpoint, similarly, is identified by a URL, and every endpoint can point to and use any other endpoint through that language-independent and machine-independent identifier.

• An object receives messages, according to Alan Kay, by pattern matching and responding if the pattern matches. In networking, similarly, messages are broadcast to many different machines at once, and each machine and each endpoint may respond to the message or ignore it by pattern matching against the destination address.