Computing Reviews
Today's Issue Hot Topics Search Browse Recommended My Account Log In
Review Help
Search
Software reading techniques : twenty techniques for more effective software review and inspection
Zhu Y., Apress, New York, NY, 2016. 126 pp. Type: Book (978-1-484223-45-1)
Date Reviewed: Sep 14 2017

Software professionals are trained to create software artifacts of all kinds. Surprisingly, they are not taught how to read and analyze the resulting requirements, designs, test cases, and code. Yang-Ming Zhu’s short book intends to address this by describing and promoting proven reading techniques used in practice. Eight chapters cover generic software reading techniques that apply to any artifact and specific techniques that apply only to requirements, designs, or code. The chapters are mostly self-contained, each with a complete list of references.

Chapter 1 briefly introduces software reviews and inspections. Chapter 2 covers general review practices, describes Fagan inspections, and examines questions such as the best team size and whether to hold an inspection meeting. Active design reviews, using questions the reviewer must answer, are presented as a way to avoid problems with Fagan reviews such as incompleteness and shallowness.

Chapter 3 covers three basic software reading techniques applicable to all software. Ad hoc reading is just the typical unstructured approach used when not doing anything else. Checklist-based reading uses a specific list of defects to look for. Differential reading compares two versions of a design, specification, or program, looking at the differences between them. This is often combined with checklist reading. These are common techniques--according to industry data cited by the author, ad hoc reading is used in 35 percent of reviews and checklist reading in 50 percent, with all other techniques used 15 percent of the time.

Two scenario-based techniques are covered in chapter 4: defect-based reading and perspective-based reading. Function-point-based reading is also described for requirements based on function-point analysis.

Requirement-specific reading techniques are presented in chapter 5. Combined reading uses the previously described defect-based reading and perspective-based reading in combination with checklist-based reading. Test-based reading uses the development of test cases based on the requirements to check the requirements’ correctness.

Three reading techniques specific to designs are described in chapter 6: usage-based reading techniques, traceability-based reading, and architecture reading for architecture designs. There is also a discussion of scope-based reading, which is really a technique for construction rather than review and so seems a bit out of place.

Code-specific reading techniques are covered in chapter 7. Reading by stepwise abstraction is essentially bottom-up code reviewing. Abstraction-driven reading is basically top-down. In common practice, developers often mix these two modes. Use-case-driven reading is presented as appropriate for discovering the dynamic nature of object-oriented code. Functionality-based reading is intended for object-oriented frameworks where there may not be appropriate use cases. Task-directed reading can be used in maintenance situations when combining inspection for defects with other development tasks such as developing documentation or adding a new feature.

Chapter 8 summarizes the techniques. Despite the book’s subtitle--Twenty techniques for more effective software review and inspection--there are more or less depending on how you count. Only 17 techniques appear as top-level list items, but there are 22 if five sublist items are counted, some of which note multiple individual techniques.

A side-by-side comparison of the techniques is missing, such as a chart comparing the techniques and their measured effectiveness and efficiency. Thus, one could tell at a glance that one technique reportedly found 1.x more defects than another, but took only Y percent as much time to do so. That may not be possible since in the previous chapters the results of individual techniques are not reported consistently. Sometimes only qualitative results are given, while other times quantitative results are reported. This may be the best the author could do, if the original reports on the technique are inconsistent in this same way. Many of the results are suspect anyway, as they are often based on very small sample sizes with students as the subjects. Since many studies find individual performance in almost any aspect of software development varies by a factor of ten, that difference alone can overwhelm any difference in techniques. There is also no discussion of how these techniques might be used with or adapted for agile development.

The book’s primary audience is software engineering practitioners. As a practicing software developer who has been doing reviews and inspections on all sorts of material for many years, I highly recommend it to anyone interested in software reviews. It would also be an excellent source for software engineering researchers interested in quality assurance or software reviews. Although also intended for students, I think it is less suitable for this audience: there are no questions, exercises, or follow-up readings and too few examples.

Undergraduate students especially will lack sufficient experience with large software designs and implementations to appreciate the need for reviews and the nuances of the different techniques.

More reviews about this item: Amazon, Goodreads

Reviewer:  Andrew R. Huber Review #: CR145540 (1711-0698)
Bookmark and Share
  Reviewer Selected
Featured Reviewer
 
 
Code Inspections And Walk-Throughs (D.2.5 ... )
 
 
Management (D.2.9 )
 
 
Project And People Management (K.6.1 )
 
Would you recommend this review?
yes
no
Other reviews under "Code Inspections And Walk-Throughs": Date
Limitations of empirical testing technique knowledge
Juristo N., Moreno A., Vegas S. In Lecture notes on empirical software engineering. River Edge, NJ: World Scientific Publishing Co, Inc., 2003. Type: Book Chapter
Oct 28 2003
Combining data from reading experiments in software inspections
Wohlin C., Petersson H., Aurum A. In Lecture notes on empirical software engineering. River Edge, NJ: World Scientific Publishing Co, Inc., 2003. Type: Book Chapter
Dec 2 2003
Using multiple adaptive regression splines to support decision making in code inspections
Briand L., Freimut B., Vollei F. Journal of Systems and Software 73(2): 205-217, 2004. Type: Article
Feb 23 2005
more...

E-Mail This Printer-Friendly
Send Your Comments
Contact Us
Reproduction in whole or in part without permission is prohibited.   Copyright 1999-2024 ThinkLoud®
Terms of Use
| Privacy Policy