Alastair Dunsmore

The development and evaluation of three diverse techniques for object-oriented code inspection

We describe the development and evaluation of a rigorous approach aimed at the effective and efficient inspection of object-oriented (OO) code. Since the time that inspections were developed they have been shown to be powerful defect detection strategies. However, little research has been done to investigate their application to OO systems, which have very different structural and execution models compared to procedural systems. This suggests that inspection techniques may not be currently being deployed to their best effect in the context of large-scale OO systems. Work to date has revealed three significant issues that need to be addressed - the identification of chunks of code to be inspected, the order in which the code is read, and the resolution of frequent nonlocal references. Three techniques are developed with the aim of addressing these issues: one based on a checklist, one focused on constructing abstract specifications, and the last centered on the route that a use case takes through a system. The three approaches are evaluated empirically and, in this instance, it is suggested that the checklist is the most effective approach, but that the other techniques also have potential strengths. For the best results in a practical situation, a combination of techniques is recommended, one of which should focus specifically on the characteristics of OO.

Further investigations into the development and evaluation of reading techniques for object-oriented code inspection

This paper describes the development and experimental evaluation of a rigorous approach for effective object-oriented (OO) code inspection. Since their development, inspections have been shown to be powerful defect detection strategies but little research has been done to investigate their application to OO systems, which have very different structural and execution models compared to procedural systems. Previous investigations have demonstrated that the delocalised nature of OO software - the resolution of frequent non-local references, and the incongruous relationship between its static and dynamic representations, are primary inhibitors to its effective inspection. The experiment investigates a set of three complementary code reading techniques devised specifically to address these problems: one based on a checklist adapted to address the identified problems of OO inspections, one focused on the systematic construction of abstract specifications, and the last centered on the dynamic slice that a use-case takes through a system. The analysis shows that there is a significant difference in the number of defects found between the three reading techniques. The checklist-based technique emerges as the most effective approach but the other techniques also have noticeable strengths and so for the best results in a practical situation a combination of techniques is recommended.

Systematic object-oriented inspection — an empirical study

Software inspection is recognised as an effective defect detection technique, but research has suggested that its performance on object-oriented code may suffer as a result of the delocalised nature of the software. This leads to problems of how to segment a system into chunks, what reading strategy should be adopted to read those chunks, and how to make available necessary non-local information. This paper presents the results of an empirical investigation that compared a systematic, abstraction-driven inspection reading technique with an ad-hoc approach in an attempt to investigate these issues. The analysis shows that using the systematic technique does not significantly improve an inspectors overall defect detection performance. The systematic technique does, however, seem to have potential to help address delocalisation through the creation of abstract specifications, encourage a deeper understanding of the code being inspected, and may also help discover different defects from an ad-hoc approach. There was also positive feedback from inspectors for the rigour imposed by the systematic technique. This research suggests that a systematic, abstraction-driven reading strategy offers some potential but there are issues that need to be addressed in terms of supporting the efficient construction of abstractions and dealing with the differences between the static and dynamic views of object-oriented code.

The role of comprehension in software inspection

In spite of code inspections having been demonstrated as an effective defect detection process, little work has been done to determine how this process best supports the object-oriented paradigm. In contrast, this paradigm (or at least its questionable manifestation in C++) is well supported by tools that purport to aid comprehension. These tools typically take the form of visualisation tools designed to assist in the maintenance process, and it is natural to consider that these tools (or adaptations thereof) might also support inspection. However, since these tools claim to aid comprehension, it is important to consider the role of comprehension in inspection. Or put simply, does comprehension matter, or are there simple techniques in existence which are similarly effective in detecting defects? This paper presents the issues associated with inspections (and the complications presented by the object-oriented paradigm) and comprehension, and presents the results of two experiments which considered the relationship between comprehension and inspection. The results indicate a relationship, but further work is needed to determine the precise nature of this relationship and how inspections might best be supported in the future.

Practical code inspection techniques for object-oriented systems: an experimental comparison

Although inspection is established as an effective mechanism for detecting defects in procedural systems, object-oriented systems have different structural and execution models. This article describes the development and empirical investigation of three different techniques for reading OO code during inspection.