(Side note: Note that on the picture above, I drew a line to separate compile-time and run-time. But the original OOP idea concerns about the run-time only. More on that on the next section.)

It may look like that the difference between “focusing on the internal” and “focusing on the space between objects” is miniscule. I originally thought the same thing. I couldn’t have been more wrong.

The difference matters so much, but it took me long time to see it because it requires different mindset.

Local retention, protection, and hiding of state-process

This idea can be thought of the higher kind of encapsulation. I personally think that this one idea that most of us can easily grasp. But one should be careful not to equate this with encapsulation in mainstream OOP. To quote Alan Kay (emphasis mine):

However, doing encapsulation right is a commitment not just to abstraction of state, but to eliminate state oriented metaphors from programming.

Getter and setter certainly don’t conform with this idea.

Extreme late-binding of all things

Extreme late-binding is needed if we want to have an environment where experimentation (as needed by “thinking and learning”) is a first-class concept.

Basically, this idea can be thought of as late-binding as we found in dynamic programming language, but taken to the extreme. Just as “messaging” idea above, it’s really hard to describe this concept. So I’ll just show a short 2-minutes demo video about Light Table, which implementation close enough for this “extreme late-binding”

However, I recommend you to check out other sources to know more about this intriguing idea:

Martin Fowler, which calls this Internal Reprogrammability. A 20-minutes TED Talk by Alan Kay, in which he talks about One Laptop Per Child (OLPC). Notice that the presentation software he uses can embed all the programs he needed without switching out to another software.

“OO” System: The Internet

My friend once asked me which application/library that has the best abstraction. It’s rather hard for me to answer, because there are many great application/library out there.

But if he’d asked what computing system has the best abstraction, I’d easily answer it. For me, one system stood out and eclipses the rest: The Internet.

Internet is often mentioned by Alan Kay as the only working Object-Oriented system out there. It embodies the 3 keys ideas above really well. Further, he says:

The Internet was done so well that most people think of it as a natural resource like the Pacific Ocean, rather than something that was man-made. When was the last time a technology with a scale like that was so error-free? The Web, in comparison, is a joke. The Web was done by amateurs.

I think the comment is rather harsh. But unfortunately, he’s right.

The Internet, as a system, was turned on on January 1st, 1983. Since then, it had 100% uptime. Sure, some of its subnetworks were experiencing downtime here and there. But The Internet, as a system, have had 0% downtime.

Not only that, The Internet is always “interactive” and always at “runtime”. If you made changes on the Internet, you don’t need to restart it. It just works. It’s “extreme late-binding” at its best.

Moreover, The Internet is a really good metasystem — a system where another system is built on top of it. To built a good metasystem, its designer can’t assume what its users will built on top of it. I highly doubt Vint Cerf and Bob Kahn — the main designers of TCP/IP — would predict that The Internet will become the backbone of modern currency.

The Internet is truly an engineering masterpiece. The web, which built on top of The Internet, is nowhere close to that.

Honorable Mention for “OOP” Languages

In today’s mainstream OOP languages, do we really focus on the object? I doubt that we do. If your programming language doesn’t let you write or edit object, then maybe it’s not oriented toward objects. Ironically, programming language that often being heralded as the OOP language, Java, doesn’t have this ability. In Java, object only lives in runtime. What we write or edit in Java is class. Jim Coplien prefers to call this paradigm as Class Oriented Programming. I certainly don’t think that Class Oriented Programming is bad, but Object Oriented Programming requires different mindset.

Of course, this didn’t happen only with Java. As a rule of thumb when you wonder whether a programming language supports OOP or not, ask yourself “Does this language lets me write or edit object”?

So, what’s mainstream programming language that’s closer to OOP? As it turns out: Javascript. Brendan Eich, the Javascript designer, states that Javascript takes inspiration from Scheme and Self. Scheme is a LISP, and Self aims to be more OOP than Smalltalk. LISP and Smalltalk, if you recall, are the languages that can do OOP according to Alan Kay. (And yes, you can write or edit object in Javascript).

(Un)fortunately, the marketing team at Netscape, where Brendan Eich worked, wants Javascript to be more like Java to ease market adoption. Then Javascript becomes the most misunderstood programming language. The rest is history.

Another language worth mentioning (although much less mainstream) is Erlang. Erlang’s design coincidentally conforms with Actor Model. Actor Model itself has interesting relationship with OOP. If Javascript is interesting because it gets object idea better than the others, Erlang is interesting because it gets the messaging idea better than the others.

I should note that I’m not advocating for Javascript and Erlang. But if you understood one of them (or better: all of them), chances are it’s easier for you to get the ideas of original OOP.

(Side note: In order to solve the multiple hard problems that we face in software construction, I get the impression from Alan Kay that he doesn’t think OOP implementation (a la Smalltak) won’t get us there, though the OOP ideas might. Smalltalk might be the best solution for problems in the past, but not for what we have right now, and especially not for what he have in future.

To put in another word using our biology example: Our current abstraction can deal until “organ” scale. But in order to scale up to “organism”, we will need totally different abstraction. You contains 37 billions cell, all is working without your mind thinking about about it. Not only that, you have 100% uptime.

Software abstraction is just not there yet. Even recreating Sketchpad and GRAIL will be hard using today’s programming languages. But this should be story for another time.)

Closing Thoughts

This where I drop you, dear reader, off the journey. I hope by now you get the understanding that original OOP is not about inheritance, encapsulation, and polymorphism. The idea is much bigger than that.

As we’ve seen, things that we take for granted everyday, such as The Internet, contains many great properties that we want from a software (highly concurrent, fault-tolerant, 100% uptime, etc). I don’t even need to mention the system design that makes you you is in totally different league.

That’s why I wonder why we — as software community — doesn’t seem to learn more from them?