[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Is OO a deliberate fraud?

Ruth, Jim, and all,

This is in indirect response to Ruth Ivimey-Cook "Re: CPA 2006 - Call for
Papers", in which she laments a dismal lack of response. I think it's the
death throes of science being choked out by fake science, and I think I've
identified the culprit.

I'm posting this to both occam and OO-based supporters, to be fair, and
allow serious answers to my points. Merrill R. Chapman in his tech history
("In Search of Stupidity", Apress / Springer-Verlag, New York, 2003)
quotes, as 1992-1993 era OO definition at Borland, the following excerpt
from "What is Object-Oriented Software" by Terry Montlick
(www.softwaredesign.com), given here in full:

> An object is a 'black box' which receives and sends messages.
> A black box actually contains code (sequences of computer
> instructions) and data (information which the inctruction
> operates on). Traditionally, code and data have been kept
> apart. For example, in the C language, units of code are
> called functions, while units of data are called structures.
> Functions and structures are not formally connected in C.
> A C function can operate on more than one type of structure
> and more than one function can operate on the same structure.
> Not so for object-oriented software! In o-o (object-oriented)
> programming, code and data are merged into a single
> indivisible thing---an object. This has some big advantages,
> as you'll see in a moment. But first, here is why SDC
> developed the 'black box' metaphor for an object. A primary
> rule of object-oriented programming is that as the user of
> an object, you should never need to peek inside the box!

the definition of a process, and fits real OO (inheritance, polymorphism,
method calls) as well as a shoe fits an ear. Were they really saying that
in 1993? Because then the whole thing was fraud from day one---describing
one thing (the right thing) while doing a completely different game with,
yes, structures (objects) and functions (methods).

Processes offer the black box of freedom from side effects, while OO
offers the black box of ignorance. Inheritance, polymorphism, and
especially encapsulation say that you are supposed to treat the pushbutton
for uploading a file as the same as the pushbutton for shutting down a
nuclear reactor. Don't look inside the box; pretend they are the same. 
And if two black boxes A and B both upload files, which "impenetrable"
black box contains the shared file system and network drivers that they
CALL? This is the emperor's new clothes!

Example: I just finished examining US Patent Application 20030182503 (go
to uspto.gov > eBusiness... Patents File Search View > Search Patents and
Published Applications). It is intending to set up independent tasks, but
in [0070] it says "the group_write I/O task 352 calls (step 354) an IO
task from the disk object 225a..." That implies multiple stack nestings
and out-of-black-box side effects. That's the only example of metaphor run
amok that I can deal with this week.

This admitted metaphor (image dissimilar to reality) generates ever-huger
languages and OSs, which is proof it is bad science. The fact that it
never works without being tinkered with is further proof. OO just grabs
whatever paradigm description sounds good and applies it to itself. It's
as if the Renaissance epicycle people neutralized Kepler by saying
epicycles were ellipses. It's as fraudulent as the old practice of big
companies announcing a product to kill a smaller competitor, and then not
bothering to produce.

We can't coexist with this monster; it's killing all good science. Have
you noticed life is like a Poul Anderson novel where science is dying and
all that remains is huge, slavish technology-by-rote?

We need to go back to scratch, to static non-virtual assembly language
design, and build all serious design in a higher-level language free of OO
and other infinite metaphor. Once we control the harness, they can use OO
if they want for what it is good for: manipulating graphic widgets in a

Larry Dickson