(FORTUNE Magazine) – That's not a nice thing to say about a commercial activity that will contribute more than an estimated $50 billion this year to the economy. But it is a fundamental truth. Software customers--you, me, CIOs of multibillion-dollar companies, and 10-year-old boys saving their weekly allowance to get the latest CD-ROM simulation--have learned to live with mediocre software. We do not count on software to be intuitively easy to understand or to work consistently. Instead, we make do with our software and put up with regular, even predictable failure.

How badly does software suck?

--I write on a Macintosh PowerBook Duo 2300c with the latest version of Apple's operating system, System 7.5.3. Every time I tell the computer to shut down, using the command Apple prescribes, it crashes before it can finish turning itself off. Since I don't have time to try to figure out why this happens, I reach around back and push the on/off button.

--On Windows NT, you press the three keys, control, alt, and delete, to start using the system. With Windows 3.1 and MS-DOS, you pressed the same three keys to restart the computer. In other words, what has for years been the last-ditch response of users in trouble has become the first action they're expected to take with Microsoft's network operating system.

--When using Lotus Notes 3.0, if you try to send an e-mail message that you wrote offline, a sentence appears at the bottom of the screen saying that Notes is "Initiating transfer of messages to the server." Then the cryptic phrase disappears, leaving you wondering when the computer stopped initiating and whether your e-mail has been sent successfully.

--In Windows 95, you have to click on the start button to shut down the computer.

I'm certain that you have your own horror stories. We all agree: Software sucks. We suspect that it always will, and we are resigned to this state of affairs. There are compelling reasons why we're right.

Computers change too quickly for software to keep up.

Major computer companies now feel that they have been exceptionally successful if they can design a model that will last in the marketplace for 18 months. Unsuccessful models disappear in a few months. Most models fall somewhere in between.

At the same time, Moore's Law states that the power of the microprocessor will double every 18 months. Software is the mechanism that takes the power unleashed by Moore's Law and converts it into something useful--programs that make us want to dump our old computers and buy new ones with even faster microprocessors. Programmers don't have time to be craftsmen if they're under the gun to extract ever more functionality out of ever more powerful machines.

The struggle involves more than just trying to dream up cool shrink-wrapped applications. The new model of a PC may have a whole new way of delivering graphics to the screen, or a different way of moving information around inside the machine. Layers and layers of software that you never see are written to coordinate all this activity: "Firmware" tells each piece of hardware how to behave; "drivers" translate the user's data into instructions for the hardware and firmware; the operating system manages the other software; and so on.

Getting all these layers to work together is an enormous headache for everyone involved. The people who write the underlying software make decisions that govern how much power the people who write the shrink-wrapped applications can wring from the hardware. Their decisions can also make your old applications incompatible with your fancy new machine. Given the pace of technological change over the past 15 years, it's a miracle computers work as well as they do.

Writing software is really, really hard.

Programming requires breaking even the simplest activities into tiny little steps, stringing those steps into sequences, and then making those sequences fit together. While tools exist that make this process easier and more automated, no one has invented a way to get around the fact that one or more human beings has to define the logic of the program.

If a program gets written by just one human, it stands a good chance of working pretty well. But commercial software now almost always requires a team, which means that the quality of the software depends as much on team members' ability to communicate with one another as on any individual's skill at writing code. When more than a handful of people work on an application, they spend more time talking to each other about the programming than actually doing it. What gets lost in the process is the subtleties--the craftsman's touch.

Correcting a piece of software is even more difficult than writing it well the first time. Sometimes, going back to change a stupid design choice is more painful than paying the price of confused users and increased support costs. A project manager must constantly balance his goals and schedules against the imperative to fix flaws. In such situations, the definition of a "bug" becomes dangerously fluid.

People who write software are inherently less social than the rest of us.

This leads them sometimes to make unfathomable decisions about how a program should work.

Imagine choosing a career in which you become so involved in solving logic problems that you would fail to engage RL (real life) for months and even years. Writing software is such a consuming, obsessive passion that it's no surprise that the best programmers tend to be very different from you and me.

A key attraction for programmers is what might be called the God complex. In order to devise the logic of a program, you need to be able to envision the whole problem at a conceptual level. It's kind of like designing a world, or a universe. The programmer gets to decide everything about that world and how its elements will interact.

An old Silicon Valley joke:

Q: Why do you think God was able to create the whole world in just seven days?

A: Because he didn't have an installed base.

The joke tries to make light of how hard it is to improve an existing product with existing users. It also happens to position God as just another programmer. Given that this is how programmers think, it's hardly surprising that what they write often acts differently than what most humans might expect.

We really don't require that our software work perfectly.

Some industry sages have railed that if cars or refrigerators, say, worked as unreliably as software, the industries that build them would tank. But people buy billions of dollars worth of packaged software. They pay prices that allow software companies to make serious money. And over the life of one application, customers keep coming back for new versions, paying a little more money each time. Maybe the automobile or refrigerator manufacturers wouldn't mind being in this kind of trouble.

Indeed, this is the most important reason software sucks--we don't insist that it be any better. We behave like happy customers. Sure, we want to assert our right to complain. But we continue to shell out $50 for Myst, or $500 for Microsoft Office, or as much as $30,000 for a license from Oracle. Why? Because in spite of the stupidities we endure, the experience still seems worth the price.

We're still amazed. Software still seems magical. We don't expect to understand how it works, and we'll tolerate unreliability as long as it gives us enough of what we want.

As software makers have added more and more features to programs, some people have insisted that software is getting too complex. The refrain goes something like this: 80% of the users don't use 80% of the features of the average application, so the industry should design simpler products.

I disagree. I think customers feel protected by the 80% of the features they don't use. They believe that a really complicated, feature-laden program will always be able to do everything they ask of it. Forced to choose between a really complex program known to have some relatively minor bugs and a simpler, battle-tested program that works perfectly, customers will always buy the complex, buggy program.

So why does software suck? Because of us. We not only tolerate the fact that software sucks. We celebrate it. We reward companies that make the software that sucks the most! (And I swear I am not talking specifically about Microsoft.)

REPORTER ASSOCIATE Ed Brown

Stewart Alsop writes a column for InfoWorld and has been analyzing the computer industry since the dawn of personal computing or 1981, whichever comes later.