PSP0 Phases

Design. Creating the software structure and algorithms.
Code. Translating the algorithm into source code.
Compile. The time from the minute you first run the compiler until the code
compiles cleanly with no syntax errors reported by the compiler.
Test. Record the time you spend testing the program, identifying and
repairing defects.

Do each phase completely before proceeding to the next.

The PSP0 uses a strict "waterfall" model with explicit phase entry/exit criteria
in order to clearly distinguish initial development from rework. This is important
because to make adjustments that might improve quality we need to know:

where are quality problems originating
where are quality problems discovered
how much effort do we spend correcting them

Ch 2.12 Incremental Development is not PSP0

Incremental development is defined on page 33.

Humphrey's position: Incremental development isn't "bad", just

Process is hard to measure.
Data are difficult to interpret.
Subsequent PSP methods don't integrate well with this approach.
Data are inconsistent with other PSP students, making it diffcult for instructor to analyze, assess, and provide advice.

Examples of "difficult to interpret."

We want to be able to measure time spent on each activity. The easiest way to do that is to do each activity completely in the corresponding phase. If you don't do that, there may be a lot of designing happening during coding phase. So time in phase numbers won't reflect reality of what occurred.

We want to be able to distinguish initial development from rework. If your effort is recorded in multiple small increments, it's hard to know where the initial work was done, and which parts are rework.

Trying to make incremental development "look" like PSP0 is not PSP0.

Another approach that defeats the intent of PSP0 is to use incremental development but try to disguise it as PSP0 by not recording each increment. It's actually pretty easy to recognize. Consider this time log:

Start Stop Delta Phase
1200 1205     5 DESIGN
1205 1212     7 CODE
1212 1222    10 COMP
1222 1344    82 TEST

It's pretty easy to tell that the programmer didn't really complete each activity before proceeding to the next phase. There's probably a lot of initial design and coding that occurred during what is recorded as test. While this programmer may have literally followed the entry/exit criteria for each phase, he probably didn't follow the intent of PSP0. He probably didn't do all the initial code development in 7 minutes. There's probably a lot of initial development in TEST that can't be tracked.

We want to know which activity is really the source of defects. If the design phase is skipped, then many defects that are REALLY because of inadequate design will be recorded as injected during CODE which doesn't accurately reflect the real injection activity.

Similarly, if the coding phase is skipped many code defects will be recorded as injected during COMP.

There will be an abundance of "fix defects" that have the same inject and removal phase during TEST. Again, that's not an accurate reflection of what happened.

A reasonably competent programmer should be able to develop a module up to 100 LOC without the need for incremental development.