Once we get over our wonder at the broad capabilities of software running on modern computers and devices, we begin to ask why so much of the software we use is of questionable quality. Between vulnerabilities to malware and constant updates to correct problems, it seems that software is never stable and reliable. Why?
Software is abstract, invisible and runs at very high speed. This combination of features makes developing software the domain of a special kind of person who can deal with the abstractions and with the incredibly fine detail of software creation. Managing a group of such people also requires a special kind of talent as well, because there are tradeoffs to be made between getting new features added and stabilizing the functions that are already built-in.
Usually, the pressures of commercial software development lead software marketers to place much more emphasis on new features than on stability, because features are what differentiate one software product from another. However, the long-term stability of a product also contributes a lot to the product’s reputation.
Software testing is the usual way to verify proper functioning before shipment. But since software development routinely takes longer than anticipated, it is the testing that gets short shrift in many cases. The result is premature delivery of software that is not yet ready for commercial use.
A 2002 study commissioned by the National Institute of Standards and Technology found software bugs cost the U.S. economy about $59.5 billion annually. The same study found that more than a third of that cost — about $22.2 billion — could be eliminated by improving testing. http://on.msnbc.com/Kae58w
In addition, the operating context of software is constantly changing. As operating system upgrades are released, the software that works under that operating system often must be adapted to the upgrades. This means that a lot of the work of keeping a software package current goes to merely maintain the capabilities that were already built.
Users continue to ask for new features. And marketers want the software to be useful in more contexts – such as making an app useful on an Android phone in addition to an iPhone. These demands guarantee that a software package will always have an endless backlog of potential changes in the “to-do” list.
As more contexts are supported and more features are added, the software inevitably becomes more complex. And complexity multiplies the difficulty of testing, and also makes each change to the software riskier. The more interactions that are possible with each part of the code, the more possibilities there are for mistakes.
What can I do to help make software better?
Purchasers of software don’t have very high expectations, because the track record of the software industry does not set a very high bar. If users demanded better software and rejected poor software, software vendors would provide better packages – or go out of business. Why don’t we demand better software?
One reason is that it is hard to switch. Once we have adopted a piece of software for some function, we tend to stay with it. First of all, it’s what we are familiar with. This “makes us rather bear those ills we have than fly to others that we know not of.” [Shakespeare – Hamlet] The cost of learning a new system is high, and we tend to stay with what is familiar, even if it is painful to use.
Second, the vendors of software don’t often make it easy for us to switch to another vendor. Try taking an Access database and “porting” it to FileMaker Pro. The conversion process is a barrier that most of us are unwilling to undertake. In addition, there may be many people who need to be trained in the new system if we switch. That adds to the cost.
In the future, we should look at the cost of switching before committing to a software vendor or cloud system. The more “open” the system, the better for us in the long term.
And we should always insist on demonstrably high quality in software. Keep this in mind the next time you’re making a purchase decision.
About John Levy