Browsing by Subject "Process smells"

Filter results by typing the first few letters
Now showing 1 - 3 of 3
  • Thumbnail Image
    ItemOpen Access
    Analyzing the impact of process smells in code review
    (2022-07) Pirouzkhah, Shirin
    Code review is a valuable modern software development practice for identifying potential problems in changesets and improving source code quality in software projects. Developers adhere to specific rules and best practices in an ideal code review process. Deviations from these best practices can potentially lead to unin­tended consequences. These deviations, also known as code review process smells, affect different parts of the code review process and its outcomes. This research empirically analyzes the correlations between process smells, and the impact of code review process smells (shared knowledge, reopened issues, time to complete review (TTCR), abandoned pull requests (PRs), number or review comments, and contribution of large changeset reviewers). The relationship between smells and their impact is correlation-based, but a causal relationship is not guaranteed because proving such relationships is not straightforward. To quantitatively an­alyze the impact of smells in the code review process, we investigated 244,903 PRs from four open source software (OSS) projects from Gerrit (Qt, Eclipse, Wireshark, and LibreOffice). As a result, we discovered that the existence of a committers’ side smell in a pull request (PR) could lead to the occurrence of reviewers’ side smells in the same PR. We also observed that reviewers assigned repeatedly by the same author to review the PR have a heavier review workload. Furthermore, the ping pong reviews and large changesets are most likely to in­crease the bug reopen ratio. In addition, we noticed that the time to complete review of a smelly PR is likely to be more than time to complete review of non-smelly PR. Also, the existence of process smells in a PR effect the number of review comments in that pull request.
  • Thumbnail Image
    ItemOpen Access
    Do developers fix continuous integration smells?
    (Association for Computing Machinery, 2023-12-08) Yaşa, Ayberk; Ergül, Ege; Erdoğmus, H.; Tüzün, Eray
    Continuous Integration (CI) is a common software engineering practice in which the code changes are frequently merged into a software project repository after automated builds and tests have been successfully run. CI enables developers to quickly detect bugs, enhance the quality of the code, and shorten review times. However, developers may encounter some obstacles in following the CI principles. They may be unaware of them, they may follow the principles partially or they may even act against them. These behaviors result in CI smells. CI smells may in turn lessen the benefits of CI. Addressing CI smells rapidly allows software projects to fully reap the benefits of CI and increase its effectiveness. The main objective of this study is to investigate how frequently developers address CI smells. To achieve this objective, we first selected seven smells, then implemented scripts for detecting these smells automatically, and then ran the scripts in eight open-source software projects using GitHub Actions. To assess the resolution extent of CI smells by practitioners, we calculated the occurrences and time-to-resolution (TTR) of each smell. Our results suggest that Skipped Job smell has been fixed slightly more than other CI smells. The most frequently observed smell was Long Build, which was detected in an average of 19.03% of all CI builds. Fake Success smell does not get resolved in projects where it exists. Our study reveals that practitioners do not fix CI smells in practice. Further studies are needed to explore the underlying reasons behind this, in order to recommend more effective strategies for addressing these smells.
  • Thumbnail Image
    ItemOpen Access
    Impact of code review process smells on code smells
    (2023-01) Tuna, Erdem
    The code review process is conducted by software teams with various motivations. Among other goals, code reviews act as a gatekeeper for software quality. Software quality comprises several aspects, maintainability (i.e., code quality) being one of them. In this study, we explore whether code review process quality (as evidenced by the presence of code review process smells) influences software maintainability (as evidenced by the presence of code smells). In other words, we investigate whether smells in the code review process are related to smells in the code that was reviewed by using correlation analysis. We augment our quantitative analysis with a focus group study to learn practitioners’ opinions. Contrary to our own intuition and that of the practitioners in our focus groups, we found that code review process smells have little to no correlation with the level of code smells. Further investigations revealed that the level of code smells neither increases nor decreases in 8 out of 10 code reviews, regardless of the quality of the code review. We identified multiple potential reasons behind the counter-intuitive results based on our focus group data. Furthermore, practitioners still believe that code reviews are helpful in improving software quality. Our results imply that the community should update our goals for code review practices and reevaluate those practices to align them with more relevant and modern realities.