Code Complete

by Steve McConnell

Fault tolerance is a collection of techniques that increase a system's reliability by detecting errors, recovering from them if possible, and containing their bad effects if not.

The architecture should demonstrate that the system is technically feasible.

Robustness is the ability of a system to continue to run after it detects an error.

Design bugs are often subtle and occur by evolution with early assumptions being forgotten as new features or uses are added to a system.

The architecture should be a polished conceptual whole with few ad hoc additions.

Good software architecture is largely machine- and language-independent.

The architecture should tread the line between underspecifying and overspecifying the system.

Are the most critical classes described and justified?

Is the data design described and justified?

Are all key business rules identified and their impact on the system described?

Is the architecture designed to accommodate likely changes?

Does the architecture account for all the requirements?

Are the motivations for all major decisions provided?

By relieving the brain of all unnecessary work, a good notation sets it free to concentrate on more advanced problems, and in effect increases the mental power of the race.

Programmers working with high-level languages achieve better productivity and quality than those working with lower-level languages.

Fortran was the first high-level computer language, introducing the ideas of variables and high-level loops.

Fortran is used mainly in scientific and engineering applications.

Without a unifying discipline, your creation will be a jumble of sloppy variations in style.

One key to successful programming is avoiding arbitrary variations so that your brain can be free to focus on the variations that are really needed.

Coding-convention details are at such a level of precision that they're nearly impossible to retrofit into software after it's written.

IsFormCompleted() was the only public routine that forms were allowed to have.

Most of the important programming principles depend not on specific languages but on the way you use them.

Have you defined how much design will be done up front and how much will be done at the keyboard, while the code is being written?

Remember to program into the language, rather than programming in it.

Design is the activity that links requirements to coding and debugging.

The picture of the software designer deriving his design in a rational, error-free way from a statement of requirements is quite unrealistic.

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

The point of design is partly to create possibilities and partly to restrict possibilities.

Design involves trial and error.

Designs don't spring fully formed directly from someone's brain. They evolve and improve through design reviews, informal discussions, experience writing the code itself, and experience revising the code.

In philosophy, the essential properties are the properties that a thing must have in order to be that thing.

Accidental properties are the properties a thing just happens to have, properties that don't really bear on whether the thing is what it is.

Accidental difficulties are more prominent in early-wave development than in late-wave development.

Projects fail most often because of poor requirements, poor planning, or poor management.

When a project reaches the point at which no one completely understands the impact that code changes in one area will have on other areas, progress grinds to a halt.

The goal is to minimize the amount of a program you have to think about at any one time.

The goal of all software-design techniques is to break a complicated problem into simple pieces.

Loose coupling means designing so that you hold connections among different parts of a program to a minimum.

Extensibility means that you can enhance a system without causing violence to the underlying structure.

If all subsystems can communicate with all other subsystems, you lose the benefit of separating them at all.

The more hoses you have to disconnect and reconnect, the more wet you're going to get.

Business rules are the laws, regulations, policies, and procedures that you encode into a computer system.

An object is any specific entity that exists in your program at run time.

A class is the static thing you look at in the program listing.

Because design is nondeterministic, skillful application of an effective set of heuristics is the core activity in good software design.

Determine what can be done to each object.

Determine what each object is allowed to do to other objects.

The two generic things objects can do to each other are containment and inheritance.

Abstraction allows you to take a simpler view of a complex concept

Encapsulation says that, not only are you allowed to take a simpler view of a complex concept, you are not allowed to look at any of the details of the complex concept.