This content is taken from the Table of Contents of the book. I can think of no more important step to professional and product development than to (at minimum) be aware that these are enduring myths of software.
Studying and pondering the implications is the next step.
This listing was created to use as a searchable index. Since I am currently reviewing one a week, it is useful to know there are 65 items total (55 facts, and 10 fallacies).
Facts and Fallacies of Software Engineering, Robert L. Glass (2003)
- The most important factor in software work is the quality of the programmers.
- The best programmers are up to 28 times better than the worst programmers.
- Adding people to a late project makes it later.
- The working environment has a profound impact on productivity and quality.
Tools and Techniques
- Hype (about tools and techniques) is the plague on the house of software.
- New tools and techniques cause an initial loss of productivity/quality.
- Software developers talk a lot about tools. They evaluate quite a few, buy a fair number, and use practically none.
- One of the two most common causes of runaway projects is poor estimation.
- Most software estimates are performed at the beginning of the life cycle. This makes sense until we realize that estimates are obtained before theh requirments are defined and thus before the problem is understood. Estimation, therefore, usually occurs at the wrong time.
- Software estimation is usually done by the wrong people.
- Software estimates are rarely corrected as the project proceeds.
- Since estimates are so faulty, there is little reason to be concerned when software projects do not meet estimated targets. But everyone is concerned anyway.
- There is a disconnect between software management and their programmers. In one research study of a project that failed to meet its estimate and was seen by its management as a failure, the technical participants saw it as the most successful project they had ever worked on.
- The answer to a feasibility study is almost always “yes”.
- Reuse-in-the-small is a solved problem.
- Reuse-in-the-large remains a mostly unsolved problem.
- Reuse-in-the-large works best in families of related systems.
- There are two
rules of threein resuse:
- It is three times as difficult to build reusable components as single use components, and
- a resuable component should be tried out in three different applications before it will be sufficiently general to accept into a reuse library.
- Modification of reused code is particularly error-prone. If more than 20 to 25 percent of a component is to be revised, it is more efficient and effective to rewrite it from scratch.
- Corollary: It is almost always a mistake to modify packaged, vendor-produced software systems.
- Design pattern reuse is one solution to the problems inherent in code reuse.
- Corollary: Design patterns emerge from practice, not from theory
- For every 25 percent increase in problem complexity, there is a 100 percent increase in solution complexity. That’s not a condition to try to change (even though reducing complexity is always a desirable thing to do); that just the way it is.
- Eighty percent of software work is intellectual. A fair amount of it is creative. Little of it is clerical.
About the Life Cycle
- One of the two most common causes of runaway projects is unstable requirements.
- Requirements errors are the most expensive to fix during production.
- Missing requirements are the hardest requirements errors to correct.
- Explicit requirements ‘explode’ as implicit requirements for a solution evolve.
- There is seldom one best design solution to a software problem.
- Design is a complex, iterative process. Initial design solutions are usually wrong and certainly not optimal.
- Designer ‘primitives’ rarely match programmer ‘primitives’.
- COBOL is a very bad language, but all the others are so much worse.
- Error removal is the most time-consuming phase of the lifecycle.
- Software is usually tested at best to the 55 to 60 percent coverage level.
- 100 percent test coverage is still far from enough.
- Test tools are essential, but rarely used.
- Test automation rarely is. Most testing activities cannot be automated.
- Programmer-created, built-in debug code is an important supplement to testing tools.
Reviews and Inspections
- Rigorous inspections can remove up to 90 percent of errors before the first test case is run.
- Rigorous inspections should not replace testing.
- Post-delivery reviews, postmortems, and retrospectives are important and seldom performed.
- Reviews are both technical and sociological, and both factors must be accommodated.
- Maintenance typically consumes 40 to 80 percent (average, 60 percent) of software costs. Therefore, it is probably the most important software lifecycle phase of software.
- Corollary: Old hardware becomes obsolete; old software goes into production every night.
- Enhancements represent roughly 60 percent of maintenance costs.
- Maintenance is a solution – not a problem.
- Understanding the existing product is the most difficult maintenance task.
- Better methods lead to more maintenance, not less.
- Quality is a collection of attributes. (ED NOTE: Glass lists seven)
- Quality is not user satisfaction, meeting requirements, achieving cost and schedule, or reliability.
- There are errors that most programmers tend to make.
- Errors tend to cluster.
- There is no single best approach to software error removal.
- Residual errors will always persist. The goal should be to minimize or eliminate severe errors.
- Efficiency stems more from good design than good coding.
- High-order language code can be about 90 percent as efficient as comparable assembler code.
- There are tradeoffs between optimizing for time and optimizing for space.
- Many researchers advocate rather than investigate. As a result, (a) some advocated concepts are worth far less than their advocates believe, and (b) there is a shorage of evaluative resarch to help determine what the value of such concepts really is.
- (x) You can’t manage what you can’t measure
- (x) You can manage quality into a software product
- (x) Programming can and should be egoless
- (x) Tools and techinques: one size fits all
- (x) Software needs more methodologies
- (x) To estimate cost and schedule, first estimate lines of code.
About the Life Cycle
- (x) Random test input is a good way to optimize testing.
- (x) “Given enough eyeballs, all bugs are shallow”.
- (x) The way to predict future maintenance costs and to make product replacement descisions is to look at past cost data.
- (x) You teach people how to program by showing them how to write programs.