Page One

Campus Computing News

"Pass the word, Please"

Round Reel Revolution

Students in the Tree

ssh . . .

The New Wordmarks are Here!

The Software Crisis

RSS Matters

The Network Connection

List of the Month


Short Courses

IRC News

Staff Activities


The Software Crisis

By Dianna Mullet, Lead UNIX Systems Administrator

The headlines have been screaming about the Y2K Software Crisis for years now. Lurking behind the Y2K crisis is the real root of the problem: The Software Crisis. After five decades of progress, software development has remained a craft and has yet to emerge into a science.

What is the Chronic Software Crisis?

Is there a crisis at all? As you stroll through the aisles of neatly packaged software in your favorite computer discount store, it wouldn’t occur to you that there’s a problem. You may be surprised to learn that those familiar aisles of software represent only a small share of the software market--of the $90 Billion software market, a mere 10% of software products are "shrink wrapped" packages for personal computers. The remaining 90% of the market is comprised of large software products developed to specific customer specifications.

By today’s definition, a "large" software system is a system that contains more than 50,000 lines of high-level language code. It’s those large systems that bring the software crisis to light. If you’re familiar with large software development projects, you know that the work is done in teams consisting of project managers, requirements analysts, software engineers, documentation experts, and programmers. With so many professionals collaborating in an organized manner on a project, what’s the problem? Why is it that the team produces fewer than 10 lines of code per day over the average lifetime of the project? And why are sixty errors found per every thousand lines of code? Why is one of every three large projects scrapped before ever being completed? And why is only 1 in 8 finished software projects considered "successful?"

But wait–there’s more!

  • The cost of owning and maintaining software in the 1980’s was twice as expensive as developing the software.
  • During the 1990’s, the cost of ownership and maintenance increased by 30% over the 1980’s.
  • In 1995, statistics showed that half of surveyed development projects were operational, but were not considered successful.
  • The average software project overshoots its schedule by half.
  • Three quarters of all large software products delivered to the customer are failures that are either not used at all, or do not meet the customer’s requirements.

Software projects are notoriously behind schedule and over budget. Over the last twenty years many different paradigms have been created in attempt to make software development more predictable and controllable. While there is no single solution to the crisis, much has been learned that can directly benefit today's software projects. It appears that the Software Crisis can be boiled down to two basic sources:

  • Software development is seen as a craft, rather than an engineering discipline.
  • The approach to education taken by most higher education institutions encourages that "craft" mentality.

Software Development: Craft, or Science?

Software development today is more of a craft than a science. Developers are certainly talented and skilled, but work like craftsmen, relying on their talents and skills and using techniques that cannot be measured or reproduced. On the other hand, software engineers place emphasis on reproducible, quantifiable techniques–the marks of science. The software industry is still many years away from becoming a mature engineering discipline. Formal software engineering processes exist, but their use is not widespread. A crisis similar to the software crisis is not seen in the hardware industry, where well documented, formal processes are tried and true, and ad hoc hardware development is unheard of.

To make matters worse, software technology is constrained by hardware technology. Since hardware develops at a much faster pace than software, software developers are constantly trying to catch up and take advantage of hardware improvements. Management often encourages ad hoc software development in an attempt to get products out on time for the new hardware architectures. Design, documentation, and evaluation are of secondary importance and are omitted or completed after the fact. However, as the statistics show, the ad hoc approach just doesn’t work. Software developers have classically accepted a certain number of errors in their work as inevitable and part of the job. That mindset becomes increasingly unacceptable as software becomes embedded in more and more consumer electronics. Sixty errors per thousand lines of code is unacceptable when the code is embedded in a toaster, automobile, ATM machine or razor (let your imagination run free for a moment).

Computer Science and the Product Orientation

Software developers pick up the ad hoc approach to software development early in their computer science education, where they are taught a "product orientation" approach to software development. In the many undergraduate computer science courses I took, the existence of software engineering processes was never even mentioned. Computer science education does not provide students with the necessary skills to become effective software engineers. They are taught in a way that encourages them to be concerned only with the final outcome of their assignments–whether or not the program runs, or whether or not it runs efficiently, or whether or not they used the best possible algorithm. Those concerns in themselves are not bad. But on the other hand, they should not be the focus of a project. The focus should be on the complete process from beginning to end and beyond. Product orientation also leads to problems when the student enters the work force–not having seen how processes affect the final outcome, individual programmers tend to think their work from day to day is too "small" to warrant the application of formal methods. To become effective software engineers, students must be taught how the process and product interact. They need to see how a good process repeatedly results in a good product. Software process engineering, is, unfortunately, not taught until very late in a computer science student’s academic career (usually in graduate school), or in company sponsored classes on the job.

Mature Software

As we have seen, most software projects do not follow a formal process. The result is a product that is poorly designed and documented. Maintenance becomes problematic because without a design and documentation, it’s difficult or impossible to predict what sort of effect a simple change might have on other parts of the system.

Fortunately there is an awareness of the software crisis, and it has inspired a worldwide movement towards process improvement. Software industry leaders are beginning to see that following a formal software process consistently leads to better quality products, more efficient teams and individuals, reduced costs, and better morale.

The SEI (Software Engineering Institute: uses a Capability Maturity Model (CMM) to assess the state of an organization’s development process. Such models are nothing new–they’ve been routinely applied to industrial engineering disciplines. What’s new is the application to software development. The SEI Software CMM has become a de facto standard for assessing and improving software processes. Ratings range from Maturity Level 1, which is characterized by ad hoc development and lack of a formal software development process, up to Maturity Level 5, at which an organization not only has a formal process, but also continually refines and improves it. Each maturity level is further broken down into key process areas that indicate the areas an organization should focus on to improve its software process (e.g. requirement analysis, defect prevention, or change control).

Level 5 is very difficult to attain. In early 1995, only two projects, one at Motorola and another at Loral (the on-board space shuttle software project), had earned Maturity Level 5. Another study showed that only 2% of reviewed projects rated in the top two Maturity Levels, in spite of many of those projects placing an extreme emphasis on software process improvement. Customers contracting large projects will naturally seek organizations with high CMM ratings, and that has prompted increasingly more organizations to investigate software process improvement.

Mature software is also reusable software. Artisans are not concerned with producing standardized products, and that is a reason why there is so little interchangeability in software components. Ideally, software would be standardized to such an extent that it could be marketed as a "part", with its own part number and revision, just as though it were a hardware part. The software component interface would be compatible with any other software system. Though it would seem that nothing less than a software development revolution could make that happen, the National Institute of Standards and Technology (NIST) founded the Advanced Technology Program (ATP), one purpose of which was to encourage the development of standardized software components. Information on the NIST Advanced Technology Program can be found at

Engineering: In; Hacking: Out

The consensus seems to be that software has become too darned big to treat as a craft: talent and late-night hacking are out. The artisan approach is charming but breaks down when the system is too large for one person to comprehend on his own. And while it may not be necessary to apply formal software processes to daily programming tasks, it is important in the larger scheme of things, in that it encourages developers to think like engineers.

Further reading on Formal Methods can be found on the Formal Methods WWW site: