Protocol-Oriented Programming Is Object-Oriented Programming
Protocol-Oriented Programming is Object-Oriented Programming

Crusty here, I just saw that my young friend Dave Abrahams gave a talk that was based on a little keyboard session we had just a short while ago.  Really sharp
fellow, you know, I am sure he'll go far someday, but that's the problem with young folk these days:  they
go rushing out telling everyone what they've learned when the lesson is only one third of the way through.

You see, I was trying to impart some wisdom on the fellow using the old Hegelian dialectic:  thesis, antithesis,
synthesis.  And yes, I admit I wasn't completely honest with him, but I swear it was just a little white lie
for a good educational cause.  You see, I presented ADT (Abstract Data Type) programming to him and called
it OOP.  It's a little ruse I use from time to time, and decades of Java, C++ and C# have gone a long way
to making it an easy one.Thesis

So the thesis was simple:  we don't need all that fancy shmancy OOP stuff, we can just use old fashioned
structs 90% of the time.  In fact, I was going to show him how easy things look in MC68K assembly 
language, with a few macros for dispatch, but then thought better of it, because he might have seen
through my little educational ploy.

Of course, a lot of what I told him was nonsense, for example OOP isn't at all about subclassing, for
example the guy who coined the term, Alan I think, wrote:  "So I decided to leave out inheritance as a built-in feature until I understood it better."  So not only isn't inheritance not the defining feature of OOP as I let on, it actually 
wasn't even in the original conception of the thing that was first called "object-oriented programming".

Absolute reliance on inheritance and therefore structural relationships is, in fact, a defining feature
of ADT-oriented programming, particularly when strong type systems are involved.  But more on that later.
In fact, OOP best practices have always (since the late 80ies and early 90ies) called for composition 
to be used for known axes of customization, with inheritance used for refinement, when a component needs 
to be adapted in a more ad-hoc fashion.  If that knowledge had filtered down to young turks writing
their master's thesis back in what, 1997,
you can rest assured that the distinction was well known and not exactly rocket science.

Anyway, I kept all that from Dave in order to really get him excited about the idea I was peddling to
him, and it looks like I succeeded.  Well, a bit too well, maybe.Antithesis

Because the idea was really to first get him all excited about not needing OOP, and then turn around
and show him that all the things I had just shown him in fact were OOP.  And still are,
as a matter of fact.  Always have been.  It's that sort of confusion of conflicting truth seeming
ideas that gets the gray matter going.  You know, "sound of one hand clapping" kind of stuff.

The reason I worked with him on a little graphics context example was, of course, that I had written
a graphics context wrapper on top of CoreGraphics a good three years ago.  In Objective-C.  With a protocol
defining the, er, protocol.  It's called MPWDrawingContext
and live on github, but I also wrote about it, showed how protocols combine with blocks to make CoreGraphics patterns
easy and intuitive to use and how to combine this type of drawing context with a more advanced
OO language to make live coding/drawing possible.





And of course this is real live programming, not the "not-quite-instant replay" programming that 
is all that Swift playgrounds can provide.


The simple fact is that actual Object Oriented Programming is Protocol Oriented Programming, 
where Protocol means a set of messages that an object understands.  In a true and pure object
oriented language like Smalltalk, it is all that can be, because the only way to interact with an
object is to send messages.  Even if you do simple metaprogramming like checking the class, you are
still sending a message.  Checking for object identity?  Sending a message.  Doing more intrusive 
metaprogramming like "directly" accessing instance variables?  Message.  Control structures like
if and while?  Message.  Creating ranges?  Message.  Iterating?  Message. 
Comparing object hierarchies?  I think you get the drift.

So all interacting is via messages, and the set of messages is a protocol.  What does that make
OO?  Say it together:  Protocol Oriented Programming.Synthesis

So we don't need objects when we have POP, but at the same time POP is OOP.  Confused?  Well,
that's kind of the point of a good dialectic argument.

One possible solution to the conflict could be that we don't need any of this stuff.  C, FORTRAN
and assembly were good enough for me, they should be good enough for you.  And that's true to
a large extent.  Excellent software was written using these tools (and ones that are much, much
worse!), and tooling is not the biggest factor determining success or failure of software projects.

On the other hand, if you want to look beyond what OOP has to offer, statically typed ADT programming
is not the answer.  It is the question that OOP answered.  And statically typed ADT programming
is not Protocol Oriented Programming, OOP is POP.  Repeat after me:  OOP is POP, POP is OOP.

To go beyond OOP, we actually need to go beyond it, not step back in time to the early 90ies, forget
all we learned in the meantime and declare victory.  My personal take is that our biggest challenges
are in "the big", meaning programming in the large.  How to connect components together in a meaningful,
tractable and understandable fashion.  Programming the components is, by and large, a solved problem,
making it a tiny bit better may make us feel better, but it won't move the needle on productivity.

Making architecture malleable, user-definable and thus a first class citizen of our programming
notation, now that is a worthwhile goal and challenge.

Crusty out.

As always, comments welcome here and on HN.
