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

A. Dunsmore, M. Roper, M. Wood

Research output: Contribution to journalArticle

42 Citations (Scopus)

Abstract

This paper describes 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.
LanguageEnglish
Pages677-686
Number of pages9
JournalIEEE Transactions on Software Engineering
Volume29
Issue number8
Publication statusPublished - 2003

Fingerprint

Inspection
Codes (standards)
Specifications
Defect detection

Cite this

@article{22851134ec2c4308ac37d245d5f73cdf,
title = "The Development and evaluation of three diverse techniques for object-oriented code inspection",
abstract = "This paper describes 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.",
author = "A. Dunsmore and M. Roper and M. Wood",
year = "2003",
language = "English",
volume = "29",
pages = "677--686",
journal = "IEEE Transactions on Software Engineering",
issn = "0098-5589",
number = "8",

}

The Development and evaluation of three diverse techniques for object-oriented code inspection. / Dunsmore, A.; Roper, M.; Wood, M.

In: IEEE Transactions on Software Engineering, Vol. 29, No. 8, 2003, p. 677-686.

Research output: Contribution to journalArticle

TY - JOUR

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

AU - Dunsmore, A.

AU - Roper, M.

AU - Wood, M.

PY - 2003

Y1 - 2003

N2 - This paper describes 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.

AB - This paper describes 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.

UR - http://doi.ieeecomputersociety.org/10.1109/TSE.2003.1223643

M3 - Article

VL - 29

SP - 677

EP - 686

JO - IEEE Transactions on Software Engineering

T2 - IEEE Transactions on Software Engineering

JF - IEEE Transactions on Software Engineering

SN - 0098-5589

IS - 8

ER -