ET-SDP: Enhancing Code Embeddings with Effort-Related and Test Coverage Metrics for Improved Software Defect Prediction

Introducing dependency, exception and encapsulation metrics for object-oriented defect prediction: Complementarity with CK/MOOD metrics through empirical machine learning and statistical validation

From Bug Reports to Code Quality: A Transformer-Based Classification Approach Using CodeBERT

Maintaining code quality during software maintenance is a persistent challenge because bug-fix activities frequently introduce new code smells, accelerating long-term technical debt. Although bug-report classification has been applied to severity prediction and developer triaging, its use for proactively distinguishing Code-Quality-Impacting Bugs (CQIBs) from Non-Code-Quality-Impacting Bugs (NQIBs) remains underexplored. This paper proposes a transformer-based classification framework that fine-tunes CodeBERT on a balanced dataset of 25,000+ bug-report segments drawn from four Apache projects (Camel, CloudStack, Geode, and HBase). We evaluate two training strategies sequential transfer learning and individual fine-tuning and compare both against the published CNN-based baselines and against BERT, RoBERTa, and DeBERTa. Under 5-fold cross-validation, individual CodeBERT fine-tuning achieves weighted-F1 scores of 0.924, 0.866, 0.858, and 0.845 on Camel, CloudStack, Geode, and HBase, respectively, for an average of 0.873. Sequential transfer learning reaches a mean accuracy of 89.8% and a peak accuracy of 92.4% on Camel. CodeBERT is the best-performing transformer in this comparison, exceeding the average weighted-F1 of BERT (0.790), RoBERTa (0.753), and DeBERTa (0.742). Rigorous preprocessing, class balancing within the training folds, and stratified evaluation contribute substantially to these results.

Intelligent Bug Triaging Using CodeBERT, Graph Attention Networks, FAISS, and Explainable Machine Learning

Software bug triaging is a crucial software maintenance activity that involves assigning reported bugs to appropriate developers and determining their priority. Manual bug triaging is often time-consuming, error-prone, and inefficient for largescale software projects due to the increasing volume of bug reports. This paper presents an intelligent bug triaging framework that integrates CodeBERT, Graph Attention Networks (GAT), FAISS, XGBoost, and SHAP to automate bug analysis and improve decision-making. Initially, bug reports are preprocessed and transformed into contextual semantic embeddings using CodeBERT. FAISS performs efficient similarity search to retrieve related historical bug reports, while GAT captures relationships among bug reports, developers, and software components to enhance developer recommendation. The extracted semantic and graph-based features are combined and supplied to an XGBoost classifier for bug priority prediction. To improve model transparency, SHAP is employed to explain the contribution of individual features to each prediction. The proposed framework is deployed through a Streamlit-based web application that provides an interactive interface for bug analysis and recommendation. By combining semantic understanding, graph learning, similarity retrieval, and explainable artificial intelligence, the proposed system improves the efficiency, accuracy, and interpretability of automated bug triaging, making it suitable for large-scale software maintenance environments.

Do Pre-Trained Code Models Add Value Beyond Software Metrics in Class-Level Defect Prediction? An Empirical Study of Input Coverage, Long-Code Aggregation, and Cross-Version Generalization

Pre-trained code models are increasingly used in software engineering, yet their incremental value beyond traditional software metrics for future-version class-level defect prediction remains unclear. This study evaluates CodeBERT, GraphCodeBERT, and CodeT5 using 16,237 class-version instances from six open-source Java systems and 11 chronological train–validation–test splits. We analyze model-specific input coverage and long-code representations and test whether learned code features add value beyond metric and size controls. Overflow affected 50.7% of instances for CodeBERT and GraphCodeBERT and 39.0% for CodeT5. Defective instances overflowed more often than clean instances, and this association remained after adjustment for size and project-version effects. Long-code strategies yielded small and inconsistent gains, none of which survived Holm correction. The best code-only model achieved a mean Matthews correlation coefficient (MCC) of 0.315, compared with 0.451 for metric-based Random Forest. Fusion produced no robust incremental gain. Multi-seed fine-tuning improved mean MCC for all encoders, but none of the paired gains remained statistically significant after Holm correction, and the best fine-tuned model remained below the metric baselines. These findings indicate that pre-trained code models should be evaluated with explicit input-coverage reporting, chronological validation, strong metric baselines, and incremental-value testing.

Explainable AI-Driven Metrics for Transparent Software Quality Prediction

Accurate software quality prediction is critical for early defect identification and effective allocation of testing resources. Although machine learning (ML) and deep learning (DL) models have significantly improved defect prediction performance, their opaque nature limits transparency, interpretability, and practitioner trust. This study presents an Explainable Artificial Intelligence (XAI) driven framework for developing composite, transparent software quality metrics that integrate predictive accuracy with multi-level interpretability. The framework has been implemented and empirically validated using multiple real-world datasets. The framework combines static code metrics, process metrics, and developer activity metrics to construct robust defect prediction models using Random Forest, Gradient Boosted Trees (e.g., via the XGBoost implementation), Support Vector Machines (SVM), Logistic Regression, and attention-based Neural Networks. To enhance transparency, model agnostic explanation techniques, including SHAP and LIME, are integrated with in-model attention mechanisms to provide global and local explanations of predictions. Experiments conducted on PROMISE, open-source, and industrial datasets demonstrate that the proposed composite explainable metric achieves superior performance on the PROMISE (NASA-JM1) dataset, with the Gradient Boosted Trees model reaching an Accuracy of 0.85 and an AUC of 0.88, and consistently outperforms traditional and opaque baselines across the Eclipse JDT, Apache Commons, and Industrial datasets. Quantitative faithfulness analysis shows strong alignment between SHAP explanations and model behavior (Pearson’s r= 0.81). A controlled user study involving software developers reports a 14% improvement in decision accuracy and significantly higher confidence levels (p< 0.01) when using explainable metrics. The framework further incorporates interactive visual dashboards and textual summaries to support actionable decision-making during quality assurance processes. By bridging the gap between predictive performance and interpretability, this research demonstrates that explainability not only enhances trust but also improves the effectiveness of practical defect triage. The methodology provides a scalable and extensible foundation for transparent AI-driven software engineering tools.

Actionable insights from developer behavior: a practical approach to software defect prediction

Software defect prediction historically relies on code and history metrics, largely ignoring developer-level indicators. Yet, because defects typically stem from human error, human-factors theory offers complementary, theoretically grounded predictors. This paper introduces a framework for deriving prediction metrics from human-factors theory and instantiates it with two metrics, alertness and memory_decay, operationalizing developer cognitive state during code editing. We evaluate these metrics on twenty-one large-scale open-source projects under two complementary protocols: a discovery-oriented (in-sample) evaluation and a time-aware generalization evaluation on a subset of eighteen projects. Under discovery evaluation, models using cognitive metrics dominate state-of-the-art baselines on every project (PR-AUC 0.64 vs. 0.43), and have surfaced over thirty real, previously-unreported defects across nine critical infrastructure projects, including two assigned CVEs and accepted upstream fixes in systems such as NASA Trick. Under time-aware cross-project evaluation, cognitive metrics encode the strongest cross-project predictive signal in the benchmark: alertness ranks first by mean SHAP importance and memory_decay exhibits the lowest rank volatility, a stability independently confirmed by chance-corrected selection-stability analysis; the configuration combining cognitive and traditional metrics significantly outperforms the traditional baseline alone (Holm-corrected \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p = 0.018$$\end{document}, large effect). Furthermore, cognitive configurations demonstrate a significant, large-effect reverse generalization gap—performing better under cross-project transfer than within-project evaluation—while substituting traditional edit-frequency counts to produce calibration-neutral models. Consequently, our findings validate cognitive theory for explainable, actionable, and interpretable safety-critical defect prediction, laying empirical groundwork to evaluate analogous issues in LLM-generated code through the behavioral study of AI.