Summary: Rather than keeping to themselves, programs are starting to talk to each other to share information. The bad news is that most seem to only talk with programs from the same vendor.
Converging Outside The Lines
Coloring outside the lines is one of the last tricks you learn in school, despite how your lack of motor skills at that age may have caused a few accidental crayon lines to breach the black inked border. And like a kid with a crayon and a piece of pre-drawn artwork ready to color in, the early age of software consisted of programmers trying to fill in the borders and lines imposed by proprietary hardware or rigid operating system structures. Every program and every programmer was concerned with only one world: their own. Crashes and malfunctions were caused by programs doing the equivalent of a crayon in the hands of an unsteady artist: writing into memory outside their allocated space. This is where the General Protection Fault came from, and suddenly every operating system maker was playing with the idea of protected memory and programs that were isolated from any outside influence - to the extent of running them inside their own little electronic jail cell.
It's different now because, like an artist realizing that the pencil lines you sketch out are only meant to be guides and it gets to be far more interesting when you deliberately color a bit outside of them, software developers are realizing that the coolest features are the ones that reach outside of the program's own little world. These could be a system wide clipboard, in its most primitive state, or it can be like an address book program that automatically captures street and e-mail addresses seen in the pages you visit with your web browser. It could be said that all of the features you could possibly put into a single program have already been thought of and implemented. The typical word processor or spreadsheet is done, the last line of code needed to implement the last useful feature was compiled three or four years ago. What's been added since then are data sharing and function sharing features.
And computer users have been lapping it up because it's actually a good idea. When most users think of their computers as being a single product, it doesn't make sense for your calculator program to be oblivious to the existence of your accounting program. So when accounting programs started coming with calculators built into them, the need for stand-alone calculator programs evaporated. It could be just as simple as inserting the result of a quick calculation into the field of a larger spreadsheet or ledger. That's the killer feature. Not programmable hotkeys, not a virtual ticker tape, not a simulated LCD display.
It hasn't quite dawned on every developer yet, so we still find ourselves using e-mail clients that don't realize there's a perfectly good address book program already installed on the computer. Or we use a paint program that assumes the Workplace Shell is just for launching programs and not document management. And we use an office suite that pretends the operating system doesn't exist. PMMail, ColorWorks and StarOffice are all very good in their class, but they act as if we should be grateful that they even know how to feed a URL to the web browser.
Or then, they understand that programs should communicate with each other, but then attempt to develop for themselves all the other programs that will be communicated with. I'm reminded of PMMail from Southsoft again, which learned how to share its address book with a newsreader - Southsoft's newsreader. StarOffice also learned how to let a presentation accept a picture or chart dragged from the desktop - StarOffice's desktop. Lacking the confidence that anyone else would make the same design decisions as they, each developer slowly tries to re-create the world in their own image and ideals. Give StarOffice a little longer and it'll turn into a full operating system. Southsoft was well on the road to making a complete internet suite. And ColorWorks, after migrating to Windows, tried to blossom out into a web graphics suite.
Self contained environments are what all of the office suites and Internet suites and miscellaneous suites are turning into, as even Microsoft gives up on OLE for anything more than its own internal system for sharing components. At this rate, the prevalent idea will cease to be one that revolves around opening up protocols and standards to let other developers write programs that peer with one another, but instead these technologies will exist to let other developers write mere supplements and plug-ins. You'll buy a computer that's utterly integrated with its one big operating-system-and-office-suite, to the point where it makes no sense to consider either of the three as separate products. You'll then buy gadgets that are activated only when they're needed by the master program. These super-systems will not be coloring outside the lines, they will have simply moved the lines to encompass more and more territory.
This desire for grand unification and convergence is what's fueling Microsoftian acquisitions of companies as much as money lust does. Computer companies rarely become conglomerates of unrelated products since they all try to capture companies making products that fit in with their existing lines. When they try real diversification they often fail, like Novell did with WordPerfect. At the time, there weren't really many ways to tie a word processor in with Netware, so with nothing to share it was like having two different companies that met at the top somewhere. (BTW: Now watch Corel plummet.)
Yet this desire for grand unification is going to produce better software when companies and groups with world-class software in their portfolio start trying to make them talk to each other some way. Lotus 1-2-3 could be paying attention to which documents you edit in Word Pro so that it can prepare a bill for the hours you spend working for each client. But with the attitude of talking to only those programs within the parent company's huge fold, there's unlikely to be a time when, for example, 1-2-3 is keeping track of what non-SmartSuite documents you edit or what client related web sites you browse.
So it's at this point in the story that, with any other columnist, the subject of open source would creep in. And the columnist would start talking about how open source is going to fix this, and how it's going to fix that, and how the world is going to be a wonderful place because you can "make install". Baby, it ain't so. Open Source is a hotbed of experimentation, but a desert of practical implementations. There's an oasis over there called Apache, and another one called Sendmail that's linked to the first by a narrow grassland of unexciting programs that you run on a server and forget about. There are two open source efforts to create integrated desktops, and when they're not trying the very best they can to copy Windows, they're on a Jihad because they can't agree on what toolkit to use. For this reason and others, I don't think they'll be agreeing on many data sharing protocols either. Half the programs will want to talk to GNOME, the others will want to talk to KDE. And just when a standard seems to be in sight, disagreements brew and they "fork the tree."
On a micro scale, hobbyists who can write in Rexx or Perl might already know the pleasures of a CD player that can tell a web server what album and track is currently being listened to, but this toy is nothing compared to a Caller-ID program that can broadcast the number of who's calling to every application on your computer. OLE and OpenDoc are quickly forgotten when your word processor is offering a button to create a letter and envelope template with the current caller's address already filled in, your browser is already suggesting his homepage, your ToDo list is already reminding you about what you wanted to say to him and your accounting program is telling you how much he owes.
|Copyright © 1999 - Falcon Networking||ISSN 1203-5696||April 1, 1999|