Fagan inspection

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

A Fagan inspection is a process of trying to find defects in documents (such as source code or formal specifications) during various phases of the software development process. It is named after Michael Fagan, who is credited[by whom?] with being the inventor of formal software inspections.

Fagan inspection defines[citation needed] a process as a certain activity with pre-specified entry and exit criteria. In every process for which entry and exit criteria are specified, Fagan inspections can be used to validate if the output of the process complies with the exit criteria specified for the process. Fagan inspection uses a group review method to evaluate the output of a given process.[citation needed]

Examples[edit]

Examples of activities for which Fagan inspection can be used are:

  • Requirement specification
  • Software/Information System architecture (for example DYA[clarification needed])[citation needed]
  • Programming (for example for iterations in XP or DSDM)
  • Software testing (for example when creating test scripts)

Usage[edit]

The software development process is a typical application of Fagan inspection. As the costs to remedy a defect are up to 10 to 100 times less in the early operations compared to fixing a defect in the maintenance phase,[citation needed] it is essential to find defects as close to the point of insertion as possible. This is done by inspecting the output of each operation and comparing that to the output requirements, or exit criteria, of that operation.

Criteria[edit]

Entry criteria are the criteria or requirements which must be met to enter a specific process.[1] For example, for Fagan inspections the high- and low-level documents must comply with specific entry criteria before they can be used for a formal inspection process.

Exit criteria are the criteria or requirements which must be met to complete a specific process. For example, for Fagan inspections the low-level document must comply with specific exit criteria (as specified in the high-level document) before the development process can be taken to the next phase.

The exit criteria are specified in a high-level document, which is then used as the standard to which the operation result (low-level document) is compared during the inspection. Any failure of the low-level document to satisfy the high-level requirements specified in the high-level document are called defects[1] (and can be further categorized as major or minor defects). Minor defects do not threaten the correct functioning of the software, but may be small errors such as spelling mistakes or unaesthetic positioning of controls in a graphical user interface.

Typical operations[edit]

A typical Fagan inspection consists of the following operations:[1]

  • Planning
    • Preparation of materials
    • Arranging of participants
    • Arranging of meeting place
  • Overview
    • Group education of participants on the materials under review
    • Assignment of roles
  • Preparation
    • The participants review the item to be inspected and supporting material to prepare for the meeting noting any questions or possible defects
    • The participants prepare their roles
  • Inspection meeting
    • Actual finding of defect
  • Rework
    • Rework is the step in software inspection in which the defects found during the inspection meeting are resolved by the author, designer or programmer. On the basis of the list of defects the low-level document is corrected until the requirements in the high-level document are met.
  • Follow-up
    • In the follow-up phase of software inspections all defects found in the inspection meeting should be corrected (as they have been fixed in the rework phase). The moderator is responsible for verifying that this is indeed the case. He should verify that all defects are fixed and no new defects are inserted while trying to fix the initial defects. It is crucial that all defects be corrected, as the costs of fixing them in a later phase of the project can be[citation needed] 10 to 100 times higher compared to the current costs.
Fagan inspection basic model

Follow-up[edit]

In the follow-up phase of a Fagan inspection, defects fixed in the rework phase should be verified. The moderator is usually responsible for verifying rework. Sometimes fixed work can be accepted without being verified, such as when the defect was trivial. In non-trivial cases, a full re-inspection is performed by the inspection team (not only the moderator).

If verification fails, go back to the rework process.

Roles[edit]

The inspection process is normally performed by members of the same team that is implementing the project. The participants fulfill different roles within the inspection process:[2][3]

  • Author/Designer/Coder: the person who wrote the low-level document
  • Reader: paraphrases the low-level document
  • Reviewers: reviews the low-level document from a testing standpoint
  • Moderator: responsible for the inspection session, functions as a coach

Benefits and results[edit]

By using inspections the number of errors in the final product can significantly decrease, creating a higher quality product. In the future the team will even be able to avoid errors as the inspection sessions give them insight into the most frequently made errors in both design and coding providing avoidance of error at the root of their occurrence. By continuously improving the inspection process these insights can even further be used [1].

Together with the qualitative benefits mentioned above major "cost improvements" can be reached as the avoidance and earlier detection of errors will reduce the amount of resources needed for debugging in later phases of the project.

In practice very positive results have been reported by large corporations such as IBM,[citation needed] indicating that 80% to 90% of defects can be found and savings in resources up to 25% can be reached.[1]

Improvements[edit]

Although the Fagan inspection method has been proved to be very effective,[citation needed] improvements have been suggested by multiple researchers. Genuchten[who?] for example has been researching the usage of an Electronic Meeting System (EMS) to improve the productivity of the meetings with positive results [4]

Other researchers propose the usage of software that keeps a database of detected errors and automatically scans program code for these common errors [5]. This again should result in improved productivity.

References[edit]

  1. ^ a b c d e Fagan, Michael E (2001) [1986]. "Advances in Software Inspections". Pioneers and Their Contributions to Software Engineering (PDF). p. 335. doi:10.1007/978-3-642-48354-7_14. ISBN 978-3-540-42290-7.
  2. ^ M.E., Fagan (1976). "Design and Code inspections to reduce errors in program development" (PDF). IBM Systems Journal. 15 (3): 182–211. doi:10.1147/sj.153.0182.
  3. ^ Eickelmann, N.S; Ruffolo, F; Baik, J; Anant, A (2003). "An empirical study of modifying the Fagan inspection process and the resulting main effects and interaction effects among defects found, effort required, rate of preparation and inspection, number of team members and product 1st pass quality". 27th Annual NASA Goddard/IEEE Software Engineering Workshop, 2002. Proceedings. p. 58. doi:10.1109/SEW.2002.1199450. ISBN 0-7695-1855-9.
  4. ^ Genuchten, M; Cornelissen, W; Van Dijk, C (Winter 1997–1998). "Supporting Inspections with an Electronic Meeting System". Journal of Management Information Systems. 14 (3): 165–179. doi:10.1080/07421222.1997.11518179.
  5. ^ Doolan, E.P. (February 1992). "Experience with Fagan's Inspection Method". Software—Practice and Experience. 22 (2): 173–182. doi:10.1002/spe.4380220205.