943 research outputs found
The evolution of the code during review: an investigation on review changes
Code review is a software engineering practice in which reviewers manually inspect the code written by a fellow developer and propose any change that is deemed necessary or useful. The main goal of code review is to improve the quality of the code under review. Despite the widespread use of code review, only a few studies focused on the investigation of its outcomes, for example, investigating the code changes that happen to the code under review. The goal of this paper is to expand our knowledge on the outcome of code review while re-evaluating results from previous work. To this aim, we analyze changes that happened during the review process, which we define as review changes. Considering three popular open-source software projects, we investigate the types of review changes (based on existing taxonomies) and what triggers them; also, we study which code factors in a code review are most related to the number of review changes. Our results show that the majority of changes relate to evolvability concerns, with a strong prevalence of documentation and structure changes at type-level. Furthermore, differently from past work, we found that the majority of review changes are not triggered by reviewers’ comments. Finally, we find that the number of review changes in a code review is related to the size of the initial patch as well as the new lines of code that it adds. However, other factors, such as lines deleted or the author of the review patchset, do not always show an empirically supported relationship with the number of changes
Explaining Explanation: An Empirical Study on Explanation in Code Reviews
Code review is an important process for quality assurance in software
development. For an effective code review, the reviewers must explain their
feedback to enable the authors of the code change to act on them. However, the
explanation needs may differ among developers, who may require different types
of explanations. It is therefore crucial to understand what kind of
explanations reviewers usually use in code reviews. To the best of our
knowledge, no study published to date has analyzed the types of explanations
used in code review. In this study, we present the first analysis of
explanations in useful code reviews. We extracted a set of code reviews based
on their usefulness and labeled them based on whether they contained an
explanation, a solution, or both a proposed solution and an explanation
thereof.
Based on our analysis, we found that a significant portion of the code review
comments (46%) only include solutions without providing an explanation. We
further investigated the remaining 54% of code review comments containing an
explanation and conducted an open card sorting to categorize the reviewers'
explanations. We distilled seven distinct categories of explanations based on
the expression forms developers used. Then, we utilize large language models,
specifically ChatGPT, to assist developers in getting a code review explanation
that suits their preferences. Specifically, we created prompts to transform a
code review explanation into a specific type of explanation. Our evaluation
results show that ChatGPT correctly generated the specified type of explanation
in 88/90 cases and that 89/90 of the cases have the correct explanation.
Overall, our study provides insights into the types of explanations that
developers use in code review and showcases how ChatGPT can be leveraged during
the code review process to generate a specific type of explanation
Code Reviewer Recommendation for Architecture Violations: An Exploratory Study
Code review is a common practice in software development and often conducted
before code changes are merged into the code repository. A number of approaches
for automatically recommending appropriate reviewers have been proposed to
match such code changes to pertinent reviewers. However, such approaches are
generic, i.e., they do not focus on specific types of issues during code
reviews. In this paper, we propose an approach that focuses on architecture
violations, one of the most critical type of issues identified during code
review. Specifically, we aim at automating the recommendation of code
reviewers, who are potentially qualified to review architecture violations,
based on reviews of code changes. To this end, we selected three common
similarity detection methods to measure the file path similarity of code
commits and the semantic similarity of review comments. We conducted a series
of experiments on finding the appropriate reviewers through evaluating and
comparing these similarity detection methods in separate and combined ways with
the baseline reviewer recommendation approach, RevFinder. The results show that
the common similarity detection methods can produce acceptable performance
scores and achieve a better performance than RevFinder. The sampling techniques
used in recommending code reviewers can impact the performance of reviewer
recommendation approaches. We also discuss the potential implications of our
findings for both researchers and practitioners.Comment: The 27th International Conference on Evaluation and Assessment in
Software Engineering (EASE
A Quality Model for Actionable Analytics in Rapid Software Development
Background: Accessing relevant data on the product, process, and usage
perspectives of software as well as integrating and analyzing such data is
crucial for getting reliable and timely actionable insights aimed at
continuously managing software quality in Rapid Software Development (RSD). In
this context, several software analytics tools have been developed in recent
years. However, there is a lack of explainable software analytics that software
practitioners trust. Aims: We aimed at creating a quality model (called
Q-Rapids quality model) for actionable analytics in RSD, implementing it, and
evaluating its understandability and relevance. Method: We performed workshops
at four companies in order to determine relevant metrics as well as product and
process factors. We also elicited how these metrics and factors are used and
interpreted by practitioners when making decisions in RSD. We specified the
Q-Rapids quality model by comparing and integrating the results of the four
workshops. Then we implemented the Q-Rapids tool to support the usage of the
Q-Rapids quality model as well as the gathering, integration, and analysis of
the required data. Afterwards we installed the Q-Rapids tool in the four
companies and performed semi-structured interviews with eight product owners to
evaluate the understandability and relevance of the Q-Rapids quality model.
Results: The participants of the evaluation perceived the metrics as well as
the product and process factors of the Q-Rapids quality model as
understandable. Also, they considered the Q-Rapids quality model relevant for
identifying product and process deficiencies (e.g., blocking code situations).
Conclusions: By means of heterogeneous data sources, the Q-Rapids quality model
enables detecting problems that take more time to find manually and adds
transparency among the perspectives of system, process, and usage.Comment: This is an Author's Accepted Manuscript of a paper to be published by
IEEE in the 44th Euromicro Conference on Software Engineering and Advanced
Applications (SEAA) 2018. The final authenticated version will be available
onlin
Are We Speeding Up or Slowing Down? On Temporal Aspects of Code Velocity
This paper investigates how the duration of various code review periods
changes over a projects' lifetime. We study four open-source software (OSS)
projects: Blender, FreeBSD, LLVM, and Mozilla. We mine and analyze the
characteristics of 283,235 code reviews that cover, on average, seven years'
worth of development. Our main conclusion is that neither the passage of time
or the project's size impact code velocity. We find that (a) the duration of
various code review periods (time-to-first-response, time-to-accept, and
time-to-merge) for FreeBSD, LLVM, and Mozilla either becomes shorter or stays
the same; no directional trend is present for Blender, (b) an increase in the
size of the code bases (annually 3-17%) does not accompany a decrease in code
velocity, and (c) for FreeBSD, LLVM, and Mozilla, the 30-day moving median
stays in a fixed range for time-to-merge. These findings do not change with
variabilities in code churn metrics, such as the number of commits or distinct
authors of code changes.Comment: 5 pages. To be published in Proceedings of MSR '23: Proceedings of
the 20th International Conference on Mining Software Repositories (MSR 2023).
May 15-16, 2023, Melbourne, Australi
Does Code Review Speed Matter for Practitioners?
Increasing code velocity is a common goal for a variety of software projects. The efficiency of the code review process significantly impacts how fast the code gets merged into the final product and reaches the customers. We conducted a survey to study the code velocity-related beliefs and practices in place. We analyzed 75 completed surveys from 39 participants from the industry and 36 from the open-source community. Our critical findings are (a) the industry and open-source community hold a similar set of beliefs, (b) quick reaction time is of utmost importance and applies to the tooling infrastructure and the behavior of other engineers, (c) time-to merge is the essential code review metric to improve, (d) engineers have differing opinions about the benefits of increased code velocity for their career growth, and (e) the controlled application of the commit-then-review model can increase code velocity. Our study supports the continued need to invest in and improve code velocity regardless of the underlying organizational ecosystem
- …