The Experts below are selected from a list of 11259 Experts worldwide ranked by ideXlab platform

Ahmed E. Hassan - One of the best experts on this subject based on the ideXlab platform.

  • An empirical study of the impact of modern Code review practices on software quality
    Empirical Software Engineering, 2016
    Co-Authors: Shane Mcintosh, Bram Adams, Yasutaka Kamei, Ahmed E. Hassan
    Abstract:

    Software Code review, i.e., the practice of having other team members critique changes to a software system, is a well-established best practice in both open source and proprietary software domains. Prior work has shown that formal Code Inspections tend to improve the quality of delivered software. However, the formal Code Inspection process mandates strict review criteria (e.g., in-person meetings and reviewer checklists) to ensure a base level of review quality, while the modern, lightweight Code reviewing process does not. Although recent work explores the modern Code review process, little is known about the relationship between modern Code review practices and long-term software quality. Hence, in this paper, we study the relationship between post-release defects (a popular proxy for long-term software quality) and: (1) Code review coverage, i.e., the proportion of changes that have been Code reviewed, (2) Code review participation, i.e., the degree of reviewer involvement in the Code review process, and (3) Code reviewer expertise, i.e., the level of domain-specific expertise of the Code reviewers. Through a case study of the Qt, VTK, and ITK projects, we find that Code review coverage, participation, and expertise share a significant link with software quality. Hence, our results empirically confirm the intuition that poorly-reviewed Code has a negative impact on software quality in large systems using modern reviewing tools.

  • the impact of Code review coverage and Code review participation on software quality a case study of the qt vtk and itk projects
    Mining Software Repositories, 2014
    Co-Authors: Shane Mcintosh, Bram Adams, Yasutaka Kamei, Ahmed E. Hassan
    Abstract:

    Software Code review, i.e., the practice of having third-party team members critique changes to a software system, is a well-established best practice in both open source and proprietary software domains. Prior work has shown that the formal Code Inspections of the past tend to improve the quality of software delivered by students and small teams. However, the formal Code Inspection process mandates strict review criteria (e.g., in-person meetings and reviewer checklists) to ensure a base level of review quality, while the modern, lightweight Code reviewing process does not. Although recent work explores the modern Code review process qualitatively, little research quantitatively explores the relationship between properties of the modern Code review process and software quality. Hence, in this paper, we study the relationship between software quality and: (1) Code review coverage, i.e., the proportion of changes that have been Code reviewed, and (2) Code review participation, i.e., the degree of reviewer involvement in the Code review process. Through a case study of the Qt, VTK, and ITK projects, we find that both Code review coverage and participation share a significant link with software quality. Low Code review coverage and participation are estimated to produce components with up to two and five additional post-release defects respectively. Our results empirically confirm the intuition that poorly reviewed Code has a negative impact on software quality in large systems using modern reviewing tools.

Lawrence G Votta - One of the best experts on this subject based on the ideXlab platform.

  • does the modern Code Inspection have value
    International Conference on Software Maintenance, 2001
    Co-Authors: Harvey Siy, Lawrence G Votta
    Abstract:

    For years, it was believed that the value of Inspections is in finding and fixing defects early in the development process. Otherwise, the cost to find and fix them later is much higher However in examining Code Inspection data, we are finding that Inspections are beneficial for an additional reason. They make the Code easier to understand and change. An analysis of data from a recent Code Inspection experiment shows that 60% of all issues raised in the Code Inspections are not problems that could have been uncovered by latter phases of testing or field usage because they have little or nothing to do with the visible execution behavior of the software. Rather they improve the maintainability of the Code by making the Code conform to coding standards, minimizing redundancies, improving language proficiency, improving safety and portability, and raising the quality of the documentation. We conclude that even if advances in software technology have diminished the value of Inspections as a defect detection tool, in most cases, it continues to be of value as a maintenance tool.

Shane Mcintosh - One of the best experts on this subject based on the ideXlab platform.

  • An empirical study of the impact of modern Code review practices on software quality
    Empirical Software Engineering, 2016
    Co-Authors: Shane Mcintosh, Bram Adams, Yasutaka Kamei, Ahmed E. Hassan
    Abstract:

    Software Code review, i.e., the practice of having other team members critique changes to a software system, is a well-established best practice in both open source and proprietary software domains. Prior work has shown that formal Code Inspections tend to improve the quality of delivered software. However, the formal Code Inspection process mandates strict review criteria (e.g., in-person meetings and reviewer checklists) to ensure a base level of review quality, while the modern, lightweight Code reviewing process does not. Although recent work explores the modern Code review process, little is known about the relationship between modern Code review practices and long-term software quality. Hence, in this paper, we study the relationship between post-release defects (a popular proxy for long-term software quality) and: (1) Code review coverage, i.e., the proportion of changes that have been Code reviewed, (2) Code review participation, i.e., the degree of reviewer involvement in the Code review process, and (3) Code reviewer expertise, i.e., the level of domain-specific expertise of the Code reviewers. Through a case study of the Qt, VTK, and ITK projects, we find that Code review coverage, participation, and expertise share a significant link with software quality. Hence, our results empirically confirm the intuition that poorly-reviewed Code has a negative impact on software quality in large systems using modern reviewing tools.

  • the impact of Code review coverage and Code review participation on software quality a case study of the qt vtk and itk projects
    Mining Software Repositories, 2014
    Co-Authors: Shane Mcintosh, Bram Adams, Yasutaka Kamei, Ahmed E. Hassan
    Abstract:

    Software Code review, i.e., the practice of having third-party team members critique changes to a software system, is a well-established best practice in both open source and proprietary software domains. Prior work has shown that the formal Code Inspections of the past tend to improve the quality of software delivered by students and small teams. However, the formal Code Inspection process mandates strict review criteria (e.g., in-person meetings and reviewer checklists) to ensure a base level of review quality, while the modern, lightweight Code reviewing process does not. Although recent work explores the modern Code review process qualitatively, little research quantitatively explores the relationship between properties of the modern Code review process and software quality. Hence, in this paper, we study the relationship between software quality and: (1) Code review coverage, i.e., the proportion of changes that have been Code reviewed, and (2) Code review participation, i.e., the degree of reviewer involvement in the Code review process. Through a case study of the Qt, VTK, and ITK projects, we find that both Code review coverage and participation share a significant link with software quality. Low Code review coverage and participation are estimated to produce components with up to two and five additional post-release defects respectively. Our results empirically confirm the intuition that poorly reviewed Code has a negative impact on software quality in large systems using modern reviewing tools.

Harvey Siy - One of the best experts on this subject based on the ideXlab platform.

  • does the modern Code Inspection have value
    International Conference on Software Maintenance, 2001
    Co-Authors: Harvey Siy, Lawrence G Votta
    Abstract:

    For years, it was believed that the value of Inspections is in finding and fixing defects early in the development process. Otherwise, the cost to find and fix them later is much higher However in examining Code Inspection data, we are finding that Inspections are beneficial for an additional reason. They make the Code easier to understand and change. An analysis of data from a recent Code Inspection experiment shows that 60% of all issues raised in the Code Inspections are not problems that could have been uncovered by latter phases of testing or field usage because they have little or nothing to do with the visible execution behavior of the software. Rather they improve the maintainability of the Code by making the Code conform to coding standards, minimizing redundancies, improving language proficiency, improving safety and portability, and raising the quality of the documentation. We conclude that even if advances in software technology have diminished the value of Inspections as a defect detection tool, in most cases, it continues to be of value as a maintenance tool.

Murray Wood - One of the best experts on this subject based on the ideXlab platform.

  • the development and evaluation of three diverse techniques for object oriented Code Inspection
    IEEE Transactions on Software Engineering, 2003
    Co-Authors: Alastair Dunsmore, Marc Roper, Murray Wood
    Abstract:

    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.

  • practical Code Inspection techniques for object oriented systems an experimental comparison
    IEEE Software, 2003
    Co-Authors: Alastair Dunsmore, Marc Roper, Murray Wood
    Abstract:

    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.

  • further investigations into the development and evaluation of reading techniques for object oriented Code Inspection
    International Conference on Software Engineering, 2002
    Co-Authors: Alastair Dunsmore, Marc Roper, Murray Wood
    Abstract:

    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.