By: Frederick P. Brooks Jr.
Publisher: Addison-Wesley Professional
Pub. Date: August 02, 1995
Chapter 13 : The Whole and the Parts
In this chapter Brooks considers how to approach system testing. First he makes the elementary prescription of thoroughly of thoroughly designing the system out first which he claims, will illuminate gaps in the understanding of how the system will execute and interface with other parts through definition and specification.
Primarily Brooks advocates a top-down design process where the high level functioning and reason for the program is first enumerated as modules and then each of these parts drilled down into in "refinement steps" until there is no room for ambiguity and data representation and algorithms can be clearly defined.
Brooks then mildly advocates "structured programing" that avoids GO-TO statements but is hesitant to dismiss them completely. Using these structures reduces the risk of logical errors.
From there brooks discusses component debugging techniques in system development and begins by discussing the history of debugging.
The history starts with on-machine debugging where machine time was extremely valuable and that careful structuring of the program with planned stops were included to reveal bugs as quickly as possible was done.
Next in the history were memory dumps where "high-speed printers" were attached and programs were run until a check failed. Debugging and finding the error occurred after the machine ran.
Next was the "snapshots" method of where selective dumping and tracing were used.
Finally he mentions interactive debugging and comes to the conclusions that programmers were not realizing the full benefits of interactive debugging sessions because the sessions for debugging weren't thoroughly planned for.
Finally, Brooks moves on to system debugging (rather than component debugging). He recommends that debugged components should be used since the effects of a known bug can change in system testing.
He also commends the use of scaffolding and use of dummy components and says that the use of scaffolding actually saves time and produces a better system than if none were used at all.
Brooks also proposes that software system testing needs a "purple-wire" technique to highlight issues found in the code that matches up with the project documentation.
Finally he recommends that components should be added to the system tests one at a time so that bugs and effects are thoroughly found and attributed to the correct components.
Lastly, Brooks claims that release updates should be quantized and releases should be large and released rather infrequently for team stability.
Chapter 14 : Hatching a Catastrophe
In this chapter, Brooks explains how a projects find themselves far behind schedule and how to avoid it.
His explanation is that schedule slippage happens one day at a time rather than by catastrophic events and that the slippage isn't fully realized because problems aren't reported since no likes to be the bearer of bad news, or as Sophocles put it (switching the perspective of shame to one of blame, "None love the bearer of bad news."
To avoid slippage, Brooks recommends that milestones be "sharp" or clear and concise so that no one, in trying to avoid shame or blame, will provide overly positive reports on progress. With sharp milestones, no one can provide a falsehood about progress and progress itself is well understood.
If fuzzy (vague) milestones are used, then the milestones become millstones that tend to persist and reduce team morale.

Next, Brooks addresses the purportedly common excuse: "The Other Piece Is Late, Anwyay" and exhorts managers to get their teams to hustle and avoid those one day slips. Therefore, the manager should use critical path schedules or PERT charts where any slip moves the end date on the documentation.
Brooks claims that managers must also know their role and respect first line managers roles. Namely, the boss's role is twofold:
1) Reduce the role of conflict and inspire sharing of status (for info)
2) "Yank the rug back" (get progress going and make changes.)
To fulfill this role, bosses should make clear demarcations between when they are getting information and when they are making changes so that their workers will share their progress voluntarily and truthfully.
Chapter 15 : The Other Face
In this chapter, Brooks advice on writing code and programs that communicate to the end users and to other programmers that will modify the code later.
In order for an end user to use a program, it must make documentation about the following available:
Purpose
Environment
Domain and Range of input
Functions and algorithms used
Input-output formats
Operating Instructions
Options
Running Time
Accuracy and Checking of output
In order to believe (trust) a program, brooks recommends that releases should include a number of tests cases that can be run to show how the program reacts.
The test cases should:
illustrate commonly encountered data,
extreme cases that work,
and cases that lie beyond the extreme and are erroneous.
Lastly, the program should include documentation on how to modify the program that should provide a clear, sharp overview of the internal structure.
This can be provided through:
Flowcharts (limited)
Descriptions of algorithms
Explanation of the layout
Overview of the pass structure
Discussion of modifications planned in the original design
Brooks claims that flowcharts should only be used at the high level and are largely unnecessary.
Brooks moves on to say that programs should be self documented within the code itself with good comments, variable names, and paragraphs like description of the code within the code. Self-documented code reduces the overall need for external documentation and save time overall.
Brooks expresses limited concerns about the size of the source code with self-documented code but remains optimistic overall about the method.
Discussion :
Brooks commitment to top-down design of a system is met with agreement in my mind since it allows abstraction to occur and the designer is able to "see the forest through the trees," while still being able to discuss the details of each part.
Brooks lack of commitment in shunning go-to statements is rather funny in retrospect since they've all but disappeared in current times.
His recommendations on system testing are quite thorough and overall commendable.
His observations on the nature and mechanics of schedule slippage are perhaps the most useful thing about this round of reading and his recommendations on providing sharp milestones and splitting information gathering from actions on changing for the boss roles will surely not go unheeded by those who read it.
The Other Face chapter shows the most age in that the need to talk about self-documentation is largely a basic matter in computer science education.
He describes without explicitly stating that we should make code readable, use good variable names, and not get tied up too much on external documentation.
Overall, it was a good read.
No comments:
Post a Comment