Columns

A journalist's job is, to some extent, cynicism and belligerency. We assume everyone trying to tell us anything only wants to rip us off, usually for our cash. It's a good defensive base position that's served generations of hacks. But as an IT journalist, this approach can backfire because there are so many easy targets. Most software is expensive and half the time it doesn't work. And when it does, we can't work out which options to tick to make it work the way we want.

But the problem is, there's no real conspiracy at work here and no tangible villain to be unearthed. The problem can be pinned down to one concept: complexity. A recent Economist report cited the reduction of technological complexity as the number one priority for the entire IT industry as we move further into the new century.

Take programming, the basic soil from which all software grows. It's a prime example of how steady, unplanned accretion of complexity has reached the level of an impenetrable labyrinth: you spend more time working out how to implement the solution to a problem than solving the problem itself. Twenty years ago, if you wanted to write a piece of software you had a clear choice of programming language: BASIC C, or assembly language. Each had simple, clear benefits and simple, clear trade-offs. BASIC was easy to learn but resulted in programs that were sluggish; C was trickier to pick up but ran faster and was more powerful; assembly language was devilishly difficult but your programs ran like lightning and it gave you access to the very heart of the computer. Rather than BASIC, C and assembly language, the three could have been called Easy, Medium and Hard. Job done.

But then the few-hundred-thousand

ADVERTISEMENT

programmers in the world became a few million, and the few-hundred-thousand users became a few-hundred-million. And all the programmers had different ideas about what they wanted, so they made complex custom software tools. And all the users had different ideas about what they wanted too. And all the companies that realised how much money there was to be made from all the users came up with all their own proprietary ways of doing all the same things.

The result was one huge technological bun fight, and before anyone had a chance tolook up from their keyboard we'd arrivedhere. So when I want the modern application I'm writing to open a connection to a customised Access database programmatically, I have dozens of languages, APIs and methods to choose from. You know you're in trouble when you're not sure if you should use the OpenConnection command from the DAO API, or the Open command from the ADO API. Help!

There's a classic sociological thought-experiment question that asks: are we among the first or among the last humans? Will there be a civilisation in ten thousand years' time that will regard us as the Ancients, or will we destroy ourselves before the century draws to a close? You could apply the same question here: is computing in its infancy or is it about to become embroiled in a quagmire of pea soup from which it will never truly escape?

The natural urge is to wipe everything away and start with a clean slate. But that's never going to happen: look at the fate of the late-1990s 'new dawn' operating system, BeOS. Forgotten about it? Exactly.

But there is light. As the Economist pointed out, computing has so far moved in two clear 15-year cycles. In the first, when mainframes stalked the Earth, all technology was proprietary. In the second, when market forces flexed their muscle, all technology was based on a forced standard, usually that devised by Microsoft. But in the new, third cycle, the resulting mess is forcing industry-wide, commonly agreed standards. The most obvious of these is XML, the eXtended Markup Language, which has gained enormous support. So yes, everything will remain based on the old mess, but these new types of simple, open but powerful standards will form a sort of technological concrete to pour over the nightmare.