OOPS UPSIDE YOUR HEAD

Dick Pountain - 14/07/94 14:10 - PC Pro 


Possible column titles: Gripes of Wrath, UAE, Cut and Paste, Bad Sector.

Object-orientation; ain'tcha just sick of it? Those two O-words have
been so abused by the hype merchants that it's hard to retain any
grasp of their original meaning (sometimes I wonder if I only imagined
that they did once mean something). Just about any crummy DOS program
that features an icon in its user-interface now gets described as
object-oriented, while no antique mini-computer application is so
flabby that you can't plaster an OO layer on top of it to revive
sales. Meanwhile we are promised object-oriented operating systems
sometime soon, except they might not be quite object-oriented because
they have to stay backward compatible with DOS applications....

Actually, when not in spleen-venting mode I suppose I still believe in
the promise of object-orientation, but I've become less than hopeful
that the promise will ever be realized. In case you've forgotten,
object-orientation was supposed to confer twofold benefits:
Programmers benefit from quicker and less buggy program development
because they can reuse prefabricated and proven software objects in
the form of class-libraries; end-users are to benefit from seamlessly
integrated compound documents and true extensibility so that upgrading
just one module might enhance all your applications at once. 

Programmers have seen some limited benefits - there's no question that
programming for GUI's like Windows or the Mac becomes marginally less
tedious if you employ C++ and a class-library like Microsoft
Foundation Classes or Borland's OWL. This soothing ointment contains a
mere handful of struggling, bedraggled flies: the lack of any agreed
object interchange standard has so far prevented the interworking of
programs written using different vendor's OOP compilers; to remedy
this lack the industry has, typically, devised two incompatible
standards (IBM's SOM and Microsoft's COM) which are preparing to fight
to the death; CORBA, the standard for distributing objects over
networks has been entrusted to a committee of mostly mainframe folk
for whom small may NOT be beautiful; it's actually much easier and
quicker to develop in Visual Basic (which isn't object-oriented) and
its .VBX extensions provide the only commercial market in reusable
modules in the history of computing (so predictably Microsoft plans to
ditch them).

End-users have so far reaped mostly a load of ear-ache, and they won't
see much real benefit until we have an operating system that supports
objects 'all-the-way-down'. Let's be clear what we're talking about
here. If you install a better amplifier in your hi-fi system, you'll
automatically get better better sound from your CDs, AND your vinyl
records, AND your cassettes AND your radio tuner. If you add extra
video memory to your PC's graphics card, then all your Windows
applications will benefit from the higher screen resolution. Unlike
such component hardware systems, our current system software doesn't
support proper extensibility (except for device drivers) because it
dates from the days when each application was an island that had to
contain all its own resources.

You may well use several applications (word-processors, DTP programs)
that can check spelling, but I'll bet that they don't share the same
dictionary. Your hard disk very likely contains multiple copies of
various popular C libraries, all bound into different applications.
The Windows DLL concept went some way towards encouraging sharing such
libraries between applications, but it doesn't adequately support
inheritance that would let programmers customise DLL functions without
duplicating code. Under a real object-oriented operating system,
applications would be decomposed into much smaller components, so that
Cut-and-Paste might be one module, Search-and-Replace might be
another, Spell-Check another and so on - every application that
requires these functions would share the same module, so that when you
plug in a new upgraded version all your applications would immediately
show the benefit (just like that hi-fi example).        

If you're thinking this sounds a bit like Microsoft's OLE 2 then
you're not entirely wrong. While arguing recently with a US colleague
who's become quite fond of OLE, I criticised its size and complexity.
"It is, after all, almost a third of an operating system" he said;
"Unfortunately, the wrong third" was my reply. The original hope for
object-orientation was that it would make software smaller by reusing
great swathes of code; grafting layers upon layers (like OLE 2 over
Windows over DOS) just makes software bigger. An 'all-the-way'
object-oriented system would support major data types like formatted
text, numeric matrices, editable bitmaps and vector drawings,
compressed sound and video as core system modules - 3rd party vendors
would then combine and refine these functions via inheritance to
create say, spreadsheets, WP and DTP applications.

OK, some technical problems have arisen to dull this shining vision.
It transpires that inheritance is not as safe as once thought. Like
some grisly parody of unsafe sex, the object-oriented encapsulation
that's supposed to hide the inner workings of objects can 'leak', so
that when you plug in a new module it might break a previously working
application (through no fault of the apps author). Microsoft is
wielding this so-called 'fragile base class' problem as a weapon in
the fight between the COM and SOM standards. But I begin to sense a
bigger problem looming; software vendors are waking up to what a true
component software system could do to pricing. When two thirds of the
functionality of your word-processor is supplied by the operating
system, can you still get away with charging £375 for it? Probably
not. Oops. 

(c) Dick Pountain 2000