Smart Bug Triage: Bridging Technical Expertise and Social Dynamics for Developer Recommendation

TL;DR

In the world of open-source development, assigning the right bug to the right person is a bottleneck. This paper presents an automated framework that categorizes bugs via Concept Profiles, identifies key players using Social Network Analysis, and ranks them based on a hybrid metric of Expertise and Fixing Cost.

Background & Motivation: The "Re-assignment" Trap

When a bug report is filed in repositories like JBoss or Eclipse, it must be triaged. However, high workloads often lead to incorrect initial assignments. This triggers a chain of "re-assignments" (or bug tossing), which significantly inflates the time-to-fix. Current SOTA methods often treat triage as a simple text classification problem, ignoring the social context and the actual availability or speed of the developers.

The authors' core insight is that a developer’s suitability isn't just about what they know (keywords), but how they interact with the community and how fast they historically resolve specific bug concepts.

Methodology: From Clusters to Social Graphs

The proposed approach operates in three distinct phases:

1. Building Concept Profiles (CP)

Instead of treating every bug as an isolated text string, the authors use K-means clustering to group similar bugs.

• Concept Extraction: For each cluster, topic terms are extracted based on frequency and normalized weights.
• Mapping: New bugs are mapped to these concepts by calculating the frequency of topic terms in the report's title and description.

2. Social Network (SN) Retrieval

The system builds a social graph where:

• Nodes: Represent developers.
• Links: Represent collaborative relationships (e.g., developers commenting on each other's fixed bugs).

The probability of a developer $de{v}_i$ fixing a new bug is calculated as: $P(b_{new}|de{v}_i)=\frac{n{b}_{devi}}{\sum n{b}_{devk}}imes\frac{n{l}_{devi}}{\sum n{l}_{devk}}$ (Where $nb$ is the number of bugs fixed and $nl$ is the number of social links launched).

3. The Ranking Algorithm

The final recommendation isn't just about probability; it's about efficiency. The authors use a weighted RScore:

• Expertise (E): Ratio of fixed bugs to assigned bugs.
• Fixing Cost (C): Inverse of the average time taken to fix historical bugs.

Experimental Results

The authors tested their method against DREX (a popular KNN-based approach) and SVM-based classifiers using JBoss data.

• Key Finding: The "Recommendation-1" curve (the full proposed model) consistently stays at the top of the Precision-Recall graph.
• Ablation Insight: Removing the social network and ranking components (Recommendation-2) led to the worst performance, proving that topic modeling alone is insufficient for high-quality triage.

Critical Analysis & Conclusion

This work successfully moves the needle by proving that Social Context matters. By incorporating "Fixing Cost," the model avoids recommending "experts" who might be theoretically knowledgeable but are actually bottlenecks in terms of speed.

Limitations:

• The study relies on a specific dataset (JBoss) and might require retraining for highly specialized or smaller projects.
• The weight factor $\alpha$ (set to 0.6) is empirical; a dynamic weight based on the urgency of the bug could be a significant future improvement.

Takeaway: Future triage systems should look beyond the content of the bug and start modeling the tempo and network of the developer community.