Modeling Review History for Reviewer Recommendation:A Hypergraph Approach

Abstract: Modern code review is a critical and indispensable practice in a pull-request development paradigm that prevails in Open Source Software (OSS) development. Finding a suitable reviewer in projects with massive participants thus becomes an increasingly challenging task. Many reviewer recommendation approaches (recommenders) have been developed to support this task which apply a similar strategy, i.e. modeling the review history first then followed by predicting/recommending a reviewer based on the model. Apparently, the better the model reflects the reality in review history, the higher recommender's performance we may expect. However, one typical scenario in a pull-request development paradigm, i.e. one Pull-Request (PR) (such as a revision or addition submitted by a contributor) may have multiple reviewers and they may impact each other through publicly posted comments, has not been modeled well in existing recommenders. We adopted the hypergraph technique to model this high-order relationship (i.e. one PR with multiple reviewers herein) and developed a new recommender, namely HGRec, which is evaluated by 12 OSS projects with more than 87K PRs, 680K comments in terms of accuracy and recommendation distribution. The results indicate that HGRec outperforms the state-of-the-art recommenders on recommendation accuracy. Besides, among the top three accurate recommenders, HGRec is more likely to recommend a diversity of reviewers, which can help to relieve the core reviewers' workload congestion issue. Moreover, since HGRec is based on hypergraph, which is a natural and interpretable representation to model review history, it is easy to accommodate more types of entities and realistic relationships in modern code review scenarios. As the first attempt, this study reveals the potentials of hypergraph on advancing the pragmatic solutions for code reviewer recommendation.

• The paper introduces HGRec, a hypergraph-based model that captures multi-entity interactions in pull-request reviews for improved accuracy.
• HGRec constructs hyperedges linking PRs, reviewers, and contributors with normalized weights based on recency and file similarity.
• Evaluation on 12 GitHub OSS projects shows superior accuracy and balanced workload distribution compared to existing approaches.

Hypergraph-Based Modeling of Review History for Reviewer Recommendation

The paper "Modeling Review History for Reviewer Recommendation: A Hypergraph Approach" (2204.09526) introduces HGRec, a reviewer recommendation system for open-source software (OSS) projects that leverages hypergraph modeling to capture high-order relationships in code review history. The work addresses limitations in prior approaches by explicitly modeling the multi-reviewer, multi-entity interactions inherent in modern code review, particularly in pull-request (PR) based development.

Motivation and Problem Statement

Reviewer recommendation is a critical task in OSS projects, where the volume of PRs and the distributed nature of contributors make manual assignment infeasible. Existing approaches—heuristics-based, learning-based, and graph-based—primarily model pairwise relationships and often fail to capture the complex, high-order interactions among PRs, contributors, and multiple reviewers. This leads to suboptimal accuracy and exacerbates workload concentration among core reviewers.

Hypergraph Modeling of Review History

HGRec introduces a hypergraph-based representation, where:

• Vertices represent PRs, contributors, and reviewers.
• Hyperedges connect multiple entities, enabling the modeling of scenarios where a single PR is reviewed by multiple reviewers, and where reviewers influence each other through comments.

This approach generalizes the traditional graph model, where edges are limited to pairwise relationships, and allows for a more faithful encoding of the collaborative and interactive nature of code review.

Hypergraph Construction

The construction process involves:

• PR-Reviewer Hyperedges: Connect a PR to all its reviewers, with edge weights reflecting the number and recency of review comments.
• PR-Contributor Hyperedges: Connect a PR to its contributor, with weights based on recency.
• PR-PR Hyperedges: Connect PRs based on file path similarity and temporal proximity, capturing expertise transfer and code familiarity.

Edge weights are normalized and parameterized to control the influence of recency, reviewer activeness, and neighborhood size.

Reviewer Recommendation as Hypergraph Ranking

Given a new PR, HGRec augments the hypergraph with the new PR and its contributor, then computes a ranking over reviewers using a localized first-order approximation. The ranking objective balances proximity in the hypergraph with a regularization term, and the top-$k$ reviewers are recommended.

The ranking is computed as:

f* = (I - αA)^(-1) y

where $A$ is the normalized adjacency matrix derived from the hypergraph, $y$ is the query vector (indicating the new PR and contributor), and $\alpha$ is a regularization parameter.

Empirical Evaluation

HGRec is evaluated on 12 prominent OSS projects from GitHub, comprising over 87,000 PRs and 680,000 review comments. The evaluation benchmarks HGRec against six state-of-the-art recommenders, including heuristics-based (RevFinder, cHRev, AC), learning-based (RF), and graph-based (CN, EARec) methods.

Metrics

• Accuracy (ACC): Fraction of times a true reviewer is in the top-$k$ recommendations.
• Mean Reciprocal Rank (MRR): Average reciprocal rank of the first correct recommendation.
• Recommendation Distribution (RD): Entropy-based measure of workload balance among reviewers.

Results

• Accuracy: HGRec achieves the highest average ACC and MRR across all projects and top-$k$ settings. For example, in top-3 accuracy, HGRec outperforms all baselines on 7 out of 12 projects and achieves the best overall average.
• Workload Balance: Among the top-3 accurate recommenders, HGRec provides significantly more diverse reviewer recommendations, mitigating workload congestion for core reviewers.
• Statistical Significance: Wilcoxon Signed Rank Tests confirm that HGRec's improvements in ACC and MRR are statistically significant in most projects.

Practical Implications

Implementation Considerations

• Scalability: Hypergraph construction and ranking are computationally more intensive than pairwise graph models, especially for large projects. Efficient data structures and incremental updates are necessary for real-time deployment.
• Parameter Tuning: The model's performance is sensitive to hyperparameters (e.g., $\alpha$, neighborhood size $m$, decay $\lambda$). Empirical tuning or automated hyperparameter optimization is recommended.
• Extensibility: The hypergraph framework is flexible; additional entities (e.g., organizations, comment content) and relationships can be incorporated to further enhance recommendation quality.

Deployment Strategies

• Integration with Code Review Tools: HGRec can be integrated into platforms like GitHub or Gerrit as a microservice, periodically updating the hypergraph with new review data.
• Workload-Aware Recommendation: By adjusting parameters, project maintainers can balance between maximizing accuracy and distributing review workload, adapting to project scale and reviewer availability.

Limitations

• Data Quality: The approach assumes that historical review data accurately reflects reviewer expertise and availability. Noisy or incomplete data (e.g., superficial comments, inactive reviewers) can affect recommendation quality.
• Generalizability: The evaluation is limited to OSS projects on GitHub; adaptation to industrial or non-GitHub contexts may require additional modeling.

Theoretical and Future Directions

The introduction of hypergraph modeling in reviewer recommendation opens several avenues:

• Explainability: The explicit modeling of high-order relationships enhances interpretability, addressing a key concern in AI-driven software engineering tools.
• Hybrid Models: Combining hypergraph-based structural modeling with deep learning (e.g., hypergraph neural networks) could further improve performance and adaptability.
• Dynamic and Online Learning: Incremental hypergraph updates and online ranking algorithms can support real-time, adaptive recommendation in rapidly evolving projects.

Conclusion

HGRec demonstrates that hypergraph-based modeling of review history captures the complex, multi-entity interactions in modern code review more effectively than prior approaches. The empirical results substantiate improvements in both recommendation accuracy and workload distribution. The framework's extensibility and interpretability position it as a promising foundation for future research and practical deployment in reviewer recommendation systems.