Facts and Fallacies in Software Engineering

Facts in Software Engineering


  1. The most important factor in software work is the quality of the programmers.
  2. The best programmers are up to 28 times better than the worst programmers.
  3. Adding people to a late project makes it later.
  4. The working environment has a profound impact on productivity and quality.

Tools and Techniques

  1. Hype (about tools and techniques) is the plague on the house of software.
  2. New tools/techniques cause an initial loss of productivity/quality.
  3. Software developers talk a lot about tools, but seldom use them.


  1. One of the two most common causes of runaway projects is poor estimation.
  2. Software estimation usually occurs at the wrong time.
  3. Software estimation is usually done by the wrong people.
  4. Software estimates are rarely corrected as the project proceeds.
  5. It is not surprising that software estimates are bad. But we live and die by them anyway!
  6. There is a disconnect between software management and their programmers.
  7. The answer to a feasibility study is almost always “yes”.


  1. Reuse-in-the-small is a well-solved problem.
  2. Reuse-in-the-large remains a mostly unsolved problem.
  3. Reuse-in-the-large works best for families of related systems.
  4. Reusable components are three times as hard to build, and should be tried out in three settings.
  5. Modification of reused code is particularly error-prone.
  6. Design pattern reuse is one solution to the problems of code reuse.


  1. For every 25 percent increase in problem complexity, there is a 100 percent increase in solution complexity.
  2. Eighty percent of software work is intellectual. A fair amount of it is creative. Little of it is clerical.


  1. One of the two most common causes of runaway projects is unstable requirements.
  2. Requirements errors are the most expensive to fix during production.
  3. Missing requirements are the hardest requirements errors to correct.


  1. Explicit requirements “explode” as implicit (design) requirements for a solution evolve.
  2. There is seldom one best design solution to a software problem.
  3. Design is a complex, iterative process. Initial design solutions are usually wrong, and certainly not optimal.


  1. Designer “primitives” (solutions they can readily code) rarely match programmer “primitives”.
  2. COBOL is a very bad language, but all the others (for business applications) are so much worse.


  1. Error-removal is the most time-consuming phase of the life cycle.


  1. Software is usually tested at best at the 55-60 percent (branch) coverage level.
  2. 100 percent coverage is still far from enough.
  3. Test tools are essential, but many are rarely used.
  4. Test automation rarely is. Most testing activities cannot be automated.
  5. Programmer-created, built-in, debug code is an important supplement to testing tools.


  1. Rigorous inspections can remove up to 90 percent of errors before the first test case is run.
  2. But rigorous inspections should not replace testing.
  3. Post-delivery reviews (some call them “retrospectives”) are important, and seldom performed.
  4. Reviews are both technical and sociological, and both factors must be accommodated.


  1. Maintenance typically consumes 40-80 percent of software costs. It is probably the most important life cycle phase of software.
  2. Enhancements represent roughly 60 percent of maintenance costs.
  3. Maintenance is a solution, not a problem.
  4. Understanding the existing product is the most difficult task of maintenance.
  5. Better methods lead to MORE maintenance, not less.


  1. Quality IS: a collection of attributes.
  2. Quality is NOT: user satisfaction, meeting requirements, achieving cost/schedule, or reliability.


  1. There are errors that most programmers tend to make.
  2. Errors tend to cluster.
  3. There is no single best approach to software error removal.
  4. Residual errors will always persist. The goal should be to minimize or eliminate severe errors.


  1. Efficiency stems more from good design than good coding.
  2. High-order-language code can be about 90 percent as efficient as comparable assembler code.
  3. There are tradeoffs between size and time optimization.

About Research

  1. Many researchers advocate rather than investigate.

Fallacies in Software Engineering

About Management

  1. Fallacy: You can’t manage what you can’t measure.
  2. Fallacy: You can manage quality into a software product.


  1. Fallacy: Programming can and should be egoless.

Tools and Techniques

  1. Fallacy: Tools and techniques: one size fits all.
  2. Fallacy: Software needs more methodologies.


  1. Fallacy: To estimate cost and schedule, first estimate lines of code.


  1. Fallacy: Random test input is a good way to optimize testing.


  1. Fallacy: “Given enough eyeballs, all bugs are shallow”.


  1. Fallacy: The way to predict future maintenance cost and to make product replacement decisions is to look at past cost data.

About Education

  1. Fallacy: You teach people how to program by showing them how to write programs.

These are from Robert Glass’ book Facts and Fallacies in Software Engineering.