Quotes from Steve McConnell

By far the most common project risks in software development are poor requirements and poor project planning, thus preparation tends to focus on improving requirements and project plans.

people who believed the old theory thought the new theory was just as ridiculous then as you think the old theory is now.

developer testing should probably take 8 to 25 percent of the total project time.

Immature testing organizations tend to have about five clean tests for every dirty test.

Mature testing organizations tend to have five dirty tests for every clean test.

it's done by creating 25 times as many dirty tests

Use locking to control access to global variables. Similar to concurrency control in a multiuser database environment, locking requires that before the value of a global variable can be used or updated, the variable must be checked out. After the variable is used, it's checked back in. During the time it's in use (checked out), if some other part of the program tries to check it out, the lock/unlock routine displays an error message or fires an assertion.

Eighty percent of the errors are found in 20 percent of a project's classes or routines

Design Is a Wicked Problem Horst Rittel and Melvin Webber defined a wicked problem as one that could be clearly defined only by solving it, or by solving part of it (1973). This paradox implies, essentially, that you have to solve the problem once in order to clearly define it and then solve it again to create a solution that works.

Global data is generally subject to two problems: routines operate on global data without knowing that other routines are operating on it, and routines are aware that other routines are operating on the global data but they don't know exactly what they're doing to it.

A good estimate is an estimate that provides a clear enough view of the project reality to allow the project leadership to make good decisions about how to control the project to hit its targets.

The picture of the software designer deriving his design in a rational, error-free way from a statement of requirements is quite unrealistic. No system has ever been developed in that way, and probably none ever will. Even the small program developments shown in textbooks and papers are unreal. They have been revised and polished until the author has shown us what he wishes he had done, not what actually did happen. — David Parnas Paul Clements

In most instances, global data is really class data for a class that hasn't been designed or implemented very well. In a few instances, data really does need to be global, but accesses to it can be wrapped with access routines to minimize potential problems. In a tiny number of remaining instances, you really do need to use global data.

In software, consultants sometimes tell you to buy into certain software-development methods to the exclusion of other methods. That's unfortunate because if you buy into any single methodology 100 percent, you'll see the whole world in terms of that methodology. In some instances, you'll miss opportunities to use other methods better suited to your current problem.

One of the main differences between programs you develop in school and those you develop as a professional is that the design problems solved by school programs are rarely, if ever, wicked.

It's better to wait for a productive programmer to become available than it is to wait for the first available programmer to become productive.

Programming assignments in school are devised to move you in a beeline from beginning to end. You'd probably want to tar and feather a teacher who gave you a programming assignment, then changed the assignment as soon as you finished the design, and then changed it again just as you were about to turn in the completed program. But that very process is an everyday reality in professional programming.

the error rate in manual testing is comparable to the bug rate in the code being tested.

Design is sloppy because a good solution is often only subtly different from a poor one.

It's tempting to trivialize the power of metaphors. To each of the earlier examples, the natural response is to say, Well, of course the right metaphor is more useful. The other metaphor was wrong! Though that's a natural reaction, it's simplistic. The history of science isn't a series of switches from the wrong metaphor to the right one. It's a series of changes from worse metaphors to better ones, from less inclusive to more inclusive, from suggestive in one area to suggestive in another.

Design is also sloppy because it's hard to know when your design is good enough. How much detail is enough? How much design should be done with a formal design notation, and how much should be left to be done at the keyboard? When are you done? Since design is open-ended, the most common answer to that question is When you're out of time.

One effective approach is to determine a range of accuracy that is acceptable and then use a boolean function to determine whether the values are close enough.

code reading detected about 80 percent more faults per hour than testing

Too much of anything is bad, but too much whiskey is just enough. — Mark Twain