Re: Derived private interface

["Randy Brukardt" <randy@rrsoftware.com>]

"Jeffrey Carter" <spam.jrcarter.not@spam.not.acm.org> wrote in message 
news:iv80lh$n8m$1@tornado.tornevall.net...
> On 07/08/2011 12:23 PM, Randy Brukardt wrote:
>>
>> This particular problem has no workaround...
>
> I disagree. The use of programming by composition is an effective work 
> around to all the problems introduced by programming by extension.

Given that the problem in question is related to dynamic dispatching and has 
nothing in particular to do with extensions, this is an amazing statement.

In Claw, the primary reason for using OOP is for the dispatching -- it 
ensures that every object has handlers for each of the relevant messages, 
and also provides useful defaults. And it automatically ensures that the 
right handler is executed for each object -- no manual binding is required. 
There is some value to extensions in Claw, but not a lot.

OTOH, programming by composition would provide nothing, in that there would 
be no way to change the handlers for the base type. One could graft some 
sort of unstructured mechanism on top of the objects (possibly using 
access-to-subprograms), but this would provide many more opportunities for 
mistakes (if you forget to set the access-to-subprogram value, the routine 
might as well not exist).

Remember that there are four legs to the OOP stool: strong typing, 
encapsulation, extension, and dynamic dispatching -- and each of these is 
orthogonal to the others (shown by the fact that Ada has the first two 
without even using tagged types, that is OOP). So there is no necessary 
relationship between extension and dispatching (and working around the one 
does nothing to solve a problem that mainly depends on the other).

                              Randy.