Church of Objectology redux.

I Find Karma (
Thu, 12 Jun 97 18:30:35 PDT

This outpostmoderns postmodern itself. Apparently Rohit's friend and
mine, Bob Cringely, really enjoys Rohit's writing style.

Dave Orchard pointed out this week's Cringely column on the
dist-obj list:

Volume 1.11 a little familiar once you get into it...

It had us confused where we had seen such opinions before. In fact, one
anonymous FoRKer wrote me when he saw the post to dist-obj:

> Huh, did the dist-obj people not see Rohit's earlier rant?
> I thought you FoRKed it?

Well, Rohit did post something with similar parts to it, but Rohit's
rant it had lots of humorous references to "the object religion"...

Let's just look at a small snippet from Rohit's piece:

> 2. HTML is not a dumb rendering format for databases -- XML may soon
> make it the SOURCE format for databases. Soon, part number won't
> be conventionalized as "third bold phrase from the right", it'll be
> <PART>xxx</PART>. Can you believe that XML Document Type Definitions
> might displace IDL?

And compare it to a small snippet from Cringely's piece:

> 2) HTML is not a dumb rendering format for databases -- XML may soon
> make it the SOURCE format for databases. Soon, part number won't be
> conventionalized as "third bold phrase from the right," it'll be
> <PART>xxx</PART>. Can you believe that XML Document Type Definitions
> might displace IDL?

Interesting similarity, no?

The full text of the 1.11 Cringely [June 12, 1997] included below in
case anyone is interested...

---------------------- 8< snip here 8< ---------------------------------

June 12, 1997 * I, Cringely * Volume 1.11
PBS Online "I think, therefore, I think." I, Cringely

We have met the enemy and it is OOP: How the World Wide Web is taking
object-oriented programming away from those silly men in white coats.
By Robert X. Cringely,

There appears to be good money these days in futurism, or is it
futurology? Whatever the formal name, let's you and me declare ourselves
to be futurists and set up shop. In the same sense that Keynesian
economists only worry about the money supply and supply-side economists
think only about cutting taxes, we'll base our practice on a single
concept -- that people tend to overestimate change in the short term and
underestimate it in the long term.

This is a powerful principle and it works. Each of us can prove it from
our own experience. Here's experiment number one. Think back to when
you were seven to eight years old and you did something really, really
bad. I'm not going to tell you exactly what I did, but my Mom still
remembers it. She said the horrible words, "Wait until your father gets
home," which I was certain presaged the end of my short life. I'll bet
the same thing happened to you. And what happened when Dad got home? He
may have bellowed a bit, or worse, but you and I are both still living.
We overestimated change in the short term. We do the same thing when we
predict Apple will soon die or that the Chicago Bulls will lose the NBA

Now for experiment number two. Again remember what it was like when you
were seven to eight years old. Back then, what did you think you would
be doing with your life in 1997? I was going to be a fireman. Compare
that childhood expectation to today's reality. See? You underestimated
change in the long run.

What happens is that something unexpected always comes along to change
the plan. Maybe it was the Vietnam War, punk rock, puberty, but
something rocked us into the unexpected dimension we occupy today.

Now let's apply this principle to the everpresent subject of information
technology. To do this, we must find something that nearly everyone
expects to happen, then show how it's being flummoxed by some unexpected

This week, we'll choose object-oriented programming. Be still my heart.

If you hang with the right sort of people, object-oriented programming
(or OOP) is a big deal. It is the basis of Microsoft's upcoming
operating system, codenamed Cairo, and of Apple's upcoming operating
system, code-named Rhapsody. OOP is also at the heart of Java. OOP is a
big deal, but not as big a deal as many people think.

The one paragraph description of object-oriented programming is that
objects are chunks of code from which programs (even whole operating
systems) can be built. Objects are like bricks, and they work together
because we carefully define their shape, size, and weight, and invent
special mortar with which to hold our OOPish creations together. With
OOP, we can ideally get our bricks (our objects) from anywhere and
they'll work together. We can define objects in terms of how they are
like other objects (this is called inheritance). The whole point is to
make programs that can be built very quickly. And since OOP more or
less works, and there is a lot of money invested in it, just about
everyone expects OOP to define the future of computing, especially in

But that's not how it is working out, though for some strange reason not
many people yet agree with me. The OOP folk think they are about the
inherit the world, while I am becoming increasingly convinced they are
becoming obsolete.

What has hit the world of OOP like puberty is the Internet and the World
Wide Web. The Web has changed the whole definition of how programs will
be built in the future, but most of the bigtime OOP experts haven't even

What the OOP experts look forward to is the coming of something they
actually call Intergalactic Distributed Objects. I am not making this
up. These objects are the bricks that made up the client-server
computing revolution of the '90s.

Then came the Web. And while white-coated IS directors still talk about
setting corporate standards for object-oriented databases, their
carefully planned customer service support systems are getting blown out
of the water by a summer intern's Web server for Marketing. The
employee identification database project is suddenly sidelined in favor
of home page indexes on the Intranet. Component documentation
repositories are replaced by Alta Vista and javadoc.

It's precisely the same kind of effect that happened at Westinghouse in
1980, when the corporate computing guys decided the company would buy no
personal computers -- only to have 1000 Apple IIs running VisiCalc
appear almost instantly in corporate HQ. The Web is too useful to be
held back by stupid corporate edicts.

If the OOPniks stare long enough at the Magic Eye Shroud, everything
looks like an object. But the masses are taking a digital photograph,
slapping it on a Web page, and calling it the Magic Eye Shroud homepage,
and that's it. No further steps, no integration, no documented
interfaces, nothing that smells of object religion anywhere. Look at a
product catalog on the Web: there are pages with prices and photos and
descriptions and links. Aren't these all objects? Yup.

This is a tide that may never turn. How do we extract -- not impose --
order on the flood of information our enterprises are already putting on
the Web? Why can't we build an order-entry system that uses the Web as
its catalog rather than the other way around?

Brace yourself for three paragraphs of infinitely dense jargon. Read it
quickly and then move on. But if you are an OOP god, please get the

1) Companies like webMethods are turning pages into objects: they have a
service which goes around and extracts an interface for a dozen
companies' package-tracking FORMs, palettizes them, and allows
user/developers to easily compose a metatracker which can track a list
of packages across the entire set in minutes.

2) HTML is not a dumb rendering format for databases -- XML may soon
make it the SOURCE format for databases. Soon, part number won't be
conventionalized as "third bold phrase from the right," it'll be xxx.
Can you believe that XML Document Type Definitions might displace IDL?

3) HTTP is not a brainless host protocol for IIOP to parasite off of to
hitch a ride across firewalls. With 1.1, it has picked up prodigious
caching powers and reasonable security. How does your OO system cache
and replicate data structures?

Okay, back to English. The lay version of the crap above is that
documents are objects. And end-users create lots of documents, somehow
without consulting class hierarchies or repositories that are the guts
of formal OOP. They slap on some applets and scripts, then use robotic
services to index, locate, and pay for this stuff.

Where's the Intergalactic Distributed Object future now? On the Web. And
perhaps, just perhaps, it won't deign to be assimilated into

The conventional wisdom is that OOP is rising and victory is in sight.
In fact, the forces of ad-hoc mediocrity are eroding away the support
for elaborate plans. The OOP crowd can fight this trend, but they can't
win. The smartest OOP people will recognize the power in this new
reality and accept it. They'll lie back and think of England.


Bad artists copy. Great artists steal.
-- Pablo Picasso