Note: Article has been updated since original submission March 26, 2015 for a college assignment.
Summary:
The following report outlines the capabilities of software inspections. Software inspections can be used as a supplementary error-finding process to the software development scheme. They may even reduce the cost and time used by other phases in the software development process. Even more so, software inspections can improve the overall software quality of a system that may not be covered by testing. Inspections are possible and are arguably a more reliant tool for finding errors in software.
Key Things Learned
- An inspection is only as good as the person inspecting. It is hard to do a good inspection.
- Software inspections are not a replacement for any phases of the software development process, such as testing, but a supplement that makes the process more efficient and effective.
- When regularly done, software inspections is a formal process. They may be conducted regularly with specified reports that are to be documented.
- Inspections are not used as often as they could be. Many people skip over software inspections in favor of testing, although inspections can reduce the number of defects just as much as testing, if not more.
Software, Tools, Apps, Used and Evaluated
There are many self-automated tools for conducting software inspections. Some are even included within an integrated development environment (IDE). Some examples are CodeSurfer, C++ Test, and TestTrack Pro (“Tools”). But the more practical software inspections, and what this report is focused on is self-inspections. The people working on the software inspect it themselves. This can be seen as a more formal process, rather than an informal process. As earlier stated, software inspections are meant to be a formal process (Stellman and Greene). High use of software inspections will reduce cost and time inefficiencies when conducting other phases of the software process such as testing and implementation. Figure 1 is an example course of how a software inspection process may be conducted in a formal setting.
Figure 1. Chart of Inspection Meeting Script
Source: Stellman, Andrew, and Jennifer Greene. Chart of Inspection Meeting Script. Digital Image. Building Better Software. O’reilly, 10 Feb. 2015. Web. 26 Mar. 2015.
Findings:
1.1 Software Inspections
A software inspection is a process of evaluating the validity of a software system. This includes, but is not limited to source code, design models, requirements (Sommerville 666). The process is done to reduce errors that can be caught before testing and implementation of the system. Inspections are a way of finding defects at a relatively low risk (low costs, less time, etc). They can be done by self-inspection or an automated tool.
1.2 Advantages
When conducting a software inspection, such as on source code, it helps mitigate the possible errors hidden by other errors. Errors because of interactions among the system cannot be easily found by software inspections, but errors that are an error in itself can be found and fixed before any testing (Sommerville 208). If an error is found by software inspections, a developer will know where it is, and most likely know how to fix it. This will minimize the number of defects to test the number of errors will be reduced (Radice). The same cannot be said if errors are found by testing, which the error can be hidden by another error. Another advantage of software inspections is that inspections can reduce cost. It does not necessarily require more testing or tools, just knowledgeable persons who can evaluate code. Also, software inspection increase the likelihood of finding an error earlier rather than later, which tends to be cheaper (Radice). All possible errors do not show up at the same time during the software cycle. Therefore there are always reoccurring costs; inspections helps reduce the need to repeat a process with cost, such as reintegration. Figure 2 outlines the entire software activity cycle, and the number of defects throughout it. Note that with inspections, the amount of defects noticed is higher than without having inspections throughout the complete cycle.
Figure 2. Example of Defect Removal With Inspections
Source: Radice, Ron. Example of Defect Removal With Inspections. Digital image. Improve Software Quality with Software Inspections. Methods & Tools, 1 Jan. 2002. Web. 26 Mar. 2015.
Inspections also consider things beyond the source code itself. It could be the system architecture or the style of programming that is inefficient or inadequate to fit the needs of standards, clients, etc. The software quality of a system can be improved when using inspections because they help find defects that cannot be found by testing or automated tools. Inspections can improve the maintainability, reusability, efficiency, without having to conduct a test (Sommerville 209). Also if inspecting something such as the checking the architecture for defects, it is not possible to “test” this as easily as source code. Furthermore, software inspections help promote understanding of the software, since it forces developers and other workers on the project to comprehend what is going on in the system (Radice). This may help ameliorate the abilities of junior developers/workers.
1.3 Disadvantages
Software inspections are done based upon the idea that one knows how to evaluate software. That is, a person must be knowledgeable about how the source code or system should look like before it is ever implemented. If one is not knowledgeable about how the source code is to work, then a good inspection will be hard to conduct (Radice). It is necessary to have a high level of skill in terms of knowledge and style of programming, perhaps in algorithms or coding language syntax, to ensure a workable system based on using the right formulas. Since software inspections are not as practiced as they could be, there is a limited pool in which people know how to conduct a software inspection (Sommerville 666-667). Even then, many developers on projects are not necessarily masters of what they are programming and may depend on testing to find errors rather than doing self-inspections of the system. Another issue associated with software inspections is that its lack of use may be due to social concerns. Since software inspections are not highly used, managers may find the process time and cost consuming, when it actually does the opposite (Radice). Also, since there is lack of documentation that explains how well software inspections can be used, many do not find it absolutely necessary to do.
Problems / Questions / Further Work
The report has outlined the basic capabilities of software inspections. In order to get more in-depth about the process of software inspections itself, they must first be widely implemented. If anything is to be done to implement software inspections, it must be that developers have to be more willing and adamant about conducting them. Software inspections can have a greater outcome when done, rather than not doing them at all. The benefits outweigh the costs, and software inspections should be a seen as a reputable process in the software development plan. Again, a software inspection is only as good as people allow them to be. With that said, there are also automated software inspection tools, which were not covered in detail by this report that may make the transition of not using software inspection as a practice to a highly used one.
Change Control and Updates
- Version 1.0 (original) <<Julie Leong>>, <<3/26/2015>>
- Version 2.0 (updated) <<Julie Leong>>, <<5/24/2018>>
References
Radice, Ron. “Improve Software Quality with Software Inspections.” Improve Software Quality with Software Inspections. Methods & Tools, 1 Jan. 2002. Web. 26 Mar. 2015. <http://www.methodsandtools.com/archive/archive.php?id=29>.https://sw.csiac.org/databases/url/key/165/169
Sommerville, Ian. “Software Quality.” Software Engineering. 9th ed. Boston: Pearson, 2011. 208-209, 663-668. Print.
Stellman, Andrew, and Jennifer Greene. “Applied Software Project Management – Review Practices.”Building Better Software. O’reilly, 10 Feb. 2015. Web. 26 Mar. 2015. <http://www.stellman-greene.com/applied-software-project-management/applied-software-project-management-review-practices/>.
“Tools.” Inspections. Cyber Security & Information Systems Information Analysis Center, 1 Jan. 2015. Web. 26 Mar. 2015. <https://sw.csiac.org/databases/url/key/165/169>.
PandaByte 