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 championship.

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 change.

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 business.

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 noticed.

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 picture.

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 Objectology.

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.