Abstract
In large-scale software development, the priority assigned to a bug report dictates the allocation of developer resources and the urgency of the fix. However, initial priority assignments are often made under conditions of high uncertainty. This paper presents an empirical study of bug priority changes across 32 Apache projects, encompassing over 223,000 bug reports. We find that approximately 8.3% of bugs experience at least one priority change, with the majority of these adjustments occurring early in the bug's lifecycle. Our analysis reveals that priority volatility is strongly correlated with increased code and communication complexity, suggesting that priority shifts are not merely administrative corrections but indicators of inherently complex issues.
Introduction
In issue tracking systems like JIRA, priority levels—ranging from Blocker and Critical to Minor and Trivial—serve as a primary scheduling mechanism. Despite their importance, these labels are frequently assigned by reporters who may lack full context or by automated systems. When a priority is changed mid-lifecycle, it introduces "work turbulence," disrupting developer schedules and potentially delaying critical fixes.
While substantial research has focused on automated priority prediction, the actual dynamics of how and why priorities change over time have remained under-explored. This study aims to bridge that gap by investigating the temporal patterns, complexity correlations, and human factors involved in priority adjustments within the Apache Software Foundation (ASF) ecosystem.
Methodology
The researchers employed a Goal-Question-Metric (GQM) approach to structure their investigation. The study analyzed the complete history of bug reports and their associated code commits across 32 non-trivial Apache projects, including Hadoop, Spark, and Kafka.
A key component of the methodology was the classification of priority changes into four distinct temporal phases based on the bug's status at the time of the change:
- BEFORE: Changes occurring after the report is filed but before active work begins.
- PROGRESS: Changes made while the bug is being fixed (e.g., status set to "In Progress" or "Patch Available").
- REOPEN: Changes following the reopening of a previously resolved bug.
- AFTER: Changes made after the bug has been resolved or closed.
To quantify the drivers of these changes, the study measured technical complexity (Lines of Code Modified, Entropy) and communication complexity (comment count and length). Statistical significance was determined using Mann-Whitney U tests and Spearman correlations.
Empirical Findings
Frequency and Timing
The study found that priority changes are relatively rare but significant, occurring in 8.3% of the analyzed bugs. The timing of these changes is heavily front-loaded: 50.7% of all priority adjustments happen in the BEFORE phase. This suggests that as maintainers and other developers first review a report, they quickly refine the initial priority assigned by the reporter.
The "Adjacent Shift" Rule and Volatility
Most priority changes are not radical. Instead of jumping from Trivial to Blocker, 87.9% of bugs that change priority do so only once, and these changes typically move to an adjacent level (e.g., Major to Critical). This indicates that initial assignments are generally "in the ballpark" but require fine-tuning as technical details emerge.
Priority as a Complexity Signal
A major finding of the study is the strong correlation between priority volatility and issue complexity. Bugs that undergo priority changes require significantly more lines of code (LOCM) to fix and generate more extensive discussion (comments) than those with stable priorities. In 29 out of 32 projects, the difference in LOCM was statistically significant. This suggests that if a bug report is generating an unusually long discussion thread, it is a leading indicator that its priority may soon be re-evaluated.
The High-Priority Paradox
Interestingly, the study observed that bugs initially labeled with higher priorities (like Blocker) are more likely to be changed than lower-priority ones. This "High-Priority Paradox" likely stems from the increased scrutiny these labels receive; maintainers are more cautious about allowing a bug to remain a "Blocker" unless it truly meets the criteria, leading to frequent downgrades or adjustments.
Discussion and Limitations
The study highlights that priority is a dynamic attribute rather than a static label. However, several limitations must be considered. The findings are specific to the Apache ecosystem, which has a distinct culture of open-source governance and JIRA usage. Furthermore, the increasing use of automation bots in projects like Flink can influence the data, as bots may adjust priorities based on predefined rules rather than human judgment.
Conclusion
Bug priority changes are a vital part of the software maintenance process, serving as a mechanism for correcting initial uncertainty and reflecting the discovered complexity of an issue. By understanding that priority shifts often signal higher technical debt or difficulty, project managers can better anticipate "work turbulence" and allocate resources more effectively. Future work should explore whether these patterns hold true in proprietary environments and how they relate to specific bug types, such as security vulnerabilities.
Summary updated