CoChat
Sign Up
Cited by 69Software Engineering ResearchTopic ModelingSoftware Engineering Techniques and Practices

CCT5: A Code-Change-Oriented Pre-trained Model

Open access
Lin, Bo, Wang, Shangwen, Liu, Zhongxin, Liu, Yepang, Xia, Xin, Mao, Xiaoguang·2023·Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering
DOI 10.1145/3611643.3616339
Open this paper in CoChat — free accountOpen PDF

Abstract

Software is constantly changing, requiring developers to perform several derived tasks in a timely manner, such as writing a description for the intention of the code change, or identifying the defect-prone code changes. Considering that the cost of dealing with these tasks can account for a large proportion (typically around 70 percent) of the total development expenditure, automating such processes will significantly lighten the burdens of developers. To achieve such a target, existing approaches mainly rely on training deep learning models from scratch or fine-tuning existing pre-trained models on such tasks, both of which have weaknesses. Specifically, the former uses comparatively small-scale labelled data for training, making it difficult to learn and exploit the domain knowledge of programming language hidden in the large-amount unlabelled code in the wild; the latter is hard to fully leverage the learned knowledge of the pre-trained model, as existing pre-trained models are designed to encode a single code snippet rather than a code change (the difference between two code snippets). We propose to pre-train a model specially designed for code changes to better support developers in software maintenance. To this end, we first collect a large-scale dataset containing 1.5M+ pairwise data of code changes and commit messages. Based on these data, we curate five different tasks for pre-training, which equip the model with diverse domain knowledge about code changes. We fine-tune the pre-trained model, CCT5, on three widely-studied tasks incurred by code changes and two tasks specific to the code review process. Results show that CCT5 outperforms both conventional deep learning approaches and existing pre-trained models on these tasks.

The claims and statistics of this paper haven’t been checked yet.

Run the check — free, no account needed. It reads the open-access text and checks the sources it cites.

A few free checks a day · papers already verified open instantly · results are public

Integrity signals

Registry

Crossref · 10.1145/3611643.3616339

Cites

9 of 9 references verified0 citation errors · 0 not checkable

Statistics

Claims the paper makes

The claims and statistics of this paper haven’t been checked yet.

Run the check — free, no account needed. It reads the open-access text and checks the sources it cites.

A few free checks a day · papers already verified open instantly · results are public

Claims other papers make about this one

Each is checked against this paper’s own text: does it say what the citing paper says it does?

  • Existing code-change-oriented pre-trained models are all built upon CodeT5.

    “Existing code-change-oriented pre-trained models [37, 39, 84] are all built upon CodeT5.”

    From Exploring the Capabilities of LLMs for Code-Change-Related Tasks (2025) · cites this paper as [39]

    Section 4.1 (page not supplied) says CCT5’s parameters are initialized from CodeT5, supporting the claim for CCT5. Section 2.3 identifies CodeReviewer as another model aimed at modelling code changes, but our copy does not say it is built upon CodeT5. The source therefore does not support the claim that all such models are. (LLM, conf=0.84)

    Experimental — accuracy not yet measured

  • Because prior studies split training, validation, and test sets from the whole dataset, the study's experimental results can be different from theirs due to different training data sizes.

    “Note that prior studies [39, 68] split training, validation, and test sets from the whole dataset to fully explore the performance of the small model; considering the different sizes of the training data, our experimental results can be different from theirs [39, 68].”

    From Exploring the Capabilities of LLMs for Code-Change-Related Tasks (2025) · cites this paper as [39]

    Section 5.1.3 (page unavailable) says CCT5 uses a dataset randomly split into 80% training, 10% validation, and 10% test sets, supporting its identification as a study that splits the dataset. The paper does not say it did so to explore a small model’s performance or that differences in training-set size explain differences between its results and the citing authors’ results. (LLM, conf=0.82)

    Experimental — accuracy not yet measured

  • The human evaluation used 4 evaluators who are not co-authors, all with more than 5 years of software development experience and deep understanding of Computer Science.

    “Specifically, following prior studies [39, 70], we recruit 4 evaluators who are not the co-authors of this paper. All evaluators have more than 5 years of software development experience and have a deep understanding of Computer Science.”

    From Exploring the Capabilities of LLMs for Code-Change-Related Tasks (2025) · cites this paper as [39]

    Section 5.1.6 (Human Evaluation) says CCT5 recruited five Ph.D. students who were not co-authors, not four evaluators. It says they had more than five years of programming experience and majored in Computer Science; it does not describe their experience specifically as software development. (LLM, conf=0.90)

    Experimental — accuracy not yet measured

  • Each sample was labeled by more than one participant, and disagreements were resolved through discussion, so the results are reliable.

    “To address this threat, following previous studies [39, 70], each sample is labeled by more than one participant. The disagreement between the participants is resolved through discussion. We believe such results are reliable.”

    From Exploring the Capabilities of LLMs for Code-Change-Related Tasks (2025) · cites this paper as [39]

    Section 5.1.6 (Human Evaluation; page unavailable) says five participants each rated every generated message, supporting the use of multiple evaluators. It says they completed the questionnaire independently, but does not report resolving disagreements through discussion. The citing authors’ belief that their results are reliable is their own conclusion. (LLM, conf=0.86)

    Experimental — accuracy not yet measured

  • CCT5 is pre-trained with 39.6 GB of code change data collected from 35K popular GitHub repositories in six programming languages.

    “It is pre-trained with 39.6 GB of code change data collected from 35K popular GitHub repositories in six programming languages.”

    From Exploring the Capabilities of LLMs for Code-Change-Related Tasks (2025) · cites this paper as [39]

Self-check

Percentages, sums and reported differences re-computed from the paper’s own numbers.

The self-check needs the paper’s full text.

Cites

Flagged first, then by citations

Research works printed but not linked: 72

  1. Wasi Ahmad, Saikat Chakraborty, Baishakhi Ray, and Kai-Wei Chang. 2021. Uni- fied Pre-training for Program Understanding and Generation. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Compu- tational Linguistics: Human Language Technologies. 2655-2668.
  2. Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. 2018. A general path- based representation for predicting program properties. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM, 404-419. https://doi.org/10.1145/3192366.3192412 · DOI
  3. Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. 2019. code2vec: learning distributed representations of code. Proceedings of the ACM on Programming Languages 3, POPL (2019), 40:1-40:29. https://doi.org/10.1145/3290353 · DOI
  4. Muna Altherwi and Andy M Gravell. 2019. A Large-Scale Dataset of Popular Open Source Projects. J. Comput. 14, 4 (2019), 240-246.
  5. Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. 2014. Neural ma- chine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473 (2014). · arXiv
  6. Nghi DQ Bui, Yijun Yu, and Lingxiao Jiang. 2021. Infercode: Self-supervised learning of code representations by predicting subtrees. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). IEEE, 1186-1197.
  7. Saikat Chakraborty, Toufique Ahmed, Yangruibo Ding, Premkumar Devanbu, and Baishakhi Ray. 2022. NatGen: Generative pre-training by "Naturalizing" source code. In Proceedings of the 30th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM.
  8. Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. 4171-4186. https: //doi.org/10.18653/v1/n19-1423 · DOI · Paper page
  9. Martín Dias, Alberto Bacchelli, Georgios Gousios, Damien Cassou, and Stéphane Ducasse. 2015. Untangling fine-grained code changes. In 2015 IEEE 22nd Inter- national Conference on Software Analysis, Evolution, and Reengineering (SANER). IEEE, 341-350.
  10. Jinhao Dong, Yiling Lou, Qihao Zhu, Zeyu Sun, Zhilin Li, Wenjie Zhang, and Dan Hao. 2022. FIRA: Fine-Grained Graph-Based Code Change Representation for Automated Commit Message Generation. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE). 970-981. https://doi.org/10.1145/ 3510003.3510069 · DOI · Paper page
  11. Robert Dyer, Hoan Anh Nguyen, Hridesh Rajan, and Tien N Nguyen. 2013. Boa: A language and infrastructure for analyzing ultra-large-scale software repositories. In 2013 35th International Conference on Software Engineering (ICSE). IEEE, 422- 431.
  12. Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, et al. 2020. CodeBERT: A Pre- Trained Model for Programming and Natural Languages. In Findings of the Asso- ciation for Computational Linguistics: EMNLP 2020. 1536-1547.
  13. Beat Fluri, Michael Wursch, Martin PInzger, and Harald Gall. 2007. Change distilling: Tree differencing for fine-grained source code change extraction. IEEE Transactions on software engineering 33, 11 (2007), 725-743.
  14. Thomas Fritz and Gail C Murphy. 2010. Using information fragments to answer the questions developers ask. In 2010 ACM/IEEE 32nd International Conference on Software Engineering, Vol. 1. IEEE, 175-184.
  15. Michael Fu, Chakkrit Tantithamthavorn, Trung Le, Van Nguyen, and Dinh Phung. 2022. VulRepair: a T5-based automated software vulnerability repair. In Pro- ceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 935-947.
  16. Xiaodong Gu, Hongyu Zhang, and Sunghun Kim. 2018. Deep code search. In 2018 IEEE/ACM 40th International Conference on Software Engineering (ICSE). IEEE, 933-944.
  17. Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, Shujie Liu, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, et al. 2021. GraphCodeBERT: Pre-training Code Representations with Data Flow. In ICLR.
  18. Steffen Herbold, Alexander Trautsch, Benjamin Ledel, Alireza Aghamohammadi, Taher A Ghaleb, Kuljit Kaur Chahal, Tim Bossenmaier, Bhaveet Nagaria, Philip Makedonski, Matin Nili Ahmadabadi, et al. 2022. A fine-grained data set and analysis of tangling in bug fixing commits. Empirical Software Engineering 27, 6 (2022), 1-49.
  19. Kim Herzig and Andreas Zeller. 2013. The impact of tangled code changes. In 2013 10th Working Conference on Mining Software Repositories (MSR). IEEE, 121-130.
  20. Robert Heumüller, Sebastian Nielebock, and Frank Ortmeier. 2021. Exploit those code reviews! bigger data for deeper learning. In Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 1505-1509.
  21. Thong Hoang, Hoa Khanh Dam, Yasutaka Kamei, David Lo, and Naoyasu Ubayashi. 2019. DeepJIT: an end-to-end deep learning framework for just-in- time defect prediction. In 2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR). IEEE, 34-45.
  22. Thong Hoang, Hong Jin Kang, Julia Lawall, and David Lo. 2020. CC2Vec: Dis- tributed Representations of Code Changes. In Proceedings of the 42nd Interna- tional Conference on Software Engineering. ACM, 518-529. https://doi.org/10. 1145/3377811.3380361 · DOI
  23. Thong Hoang, Julia Lawall, Yuan Tian, Richard J Oentaryo, and David Lo. 2019. Patchnet: Hierarchical deep learning-based stable patch identification for the linux kernel. IEEE Transactions on Software Engineering 47, 11 (2019), 2471-2486.
  24. Xing Hu, Ge Li, Xin Xia, David Lo, and Zhi Jin. 2018. Deep Code Comment Gener- ation. In 2018 IEEE/ACM 26th International Conference on Program Comprehension (ICPC).
  25. Hamel Husain, Ho-Hsiang Wu, Tiferet Gazit, Miltiadis Allamanis, and Marc Brockschmidt. 2019. Codesearchnet challenge: Evaluating the state of semantic code search. arXiv preprint arXiv:1909.09436 (2019). · arXiv
  26. Siyuan Jiang, Ameer Armaly, and Collin McMillan. 2017. Automatically generat- ing commit messages from diffs using neural machine translation. In Proceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering. 135-146. https://doi.org/10.1109/ASE.2017.8115626 · DOI
  27. Miryung Kim and David Notkin. 2009. Discovering and representing systematic code changes. In 2009 IEEE 31st International Conference on Software Engineering. IEEE, 309-319.
  28. Sunghun Kim, E James Whitehead, and Yi Zhang. 2008. Classifying software changes: Clean or buggy? IEEE Transactions on software engineering 34, 2 (2008), 181-196.
  29. Alexander LeClair, Siyuan Jiang, and Collin McMillan. 2019. A neural model for generating natural language summaries of program subroutines. In Proceedings of the 41st International Conference on Software Engineering. 795-806. https: //doi.org/10.1109/ICSE.2019.00087 · DOI
  30. Meir M Lehman. 1980. Programs, life cycles, and laws of software evolution. Proc. IEEE 68, 9 (1980), 1060-1076.
  31. Yi Li, Shaohua Wang, Tien N Nguyen, and Son Van Nguyen. 2019. Improving bug detection via context-based code representation learning and attention-based neural networks. Proceedings of the ACM on Programming Languages 3, OOPSLA (2019), 162:1-162:30. https://doi.org/10.1145/3360588 · DOI
  32. Zhiyu Li, Shuai Lu, Daya Guo, Nan Duan, Shailesh Jannu, Grant Jenks, Deep Majumder, Jared Green, Alexey Svyatkovskiy, Shengyu Fu, and Neel Sundare- san. 2022. Automating Code Review Activities by Large-Scale Pre-Training. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2022). 1035-1047. https://doi.org/10.1145/3540250.3549081 · DOI
  33. Bo Lin, Shangwen Wang, Kui Liu, Xiaoguang Mao, and Tegawendé F. Bissyandé. 2021. Automated Comment Update: How Far are We?. In Proceedings of the 29th IEEE/ACM International Conference on Program Comprehension (ICPC). 36-46. https://doi.org/10.1109/ICPC52881.2021.00013 · DOI
  34. Bo Lin, Shangwen Wang, Ming Wen, and Xiaoguang Mao. 2022. Context-Aware Code Change Embedding for Better Patch Correctness Assessment. ACM Trans. Softw. Eng. Methodol. 31, 3, Article 51 (may 2022), 29 pages. https://doi.org/10. 1145/3505247 · DOI
  35. I-H Lin and David A Gustafson. 1988. Classifying software maintenance. In 1988 Conference on Software Maintenance. IEEE Computer Society, 241-247.
  36. Fang Liu, Ge Li, Yunfei Zhao, and Zhi Jin. 2020. Multi-task learning based pre- trained language model for code completion. In Proceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. 473-485.
  37. Haoran Liu, Yue Yu, Shanshan Li, Mingyang Geng, Xiaoguang Mao, and Xiangke Liao. 2021. How to cherry pick the bug report for better summarization? Empirical Software Engineering 26 (2021), 1-36.
  38. Zhongxin Liu, Xin Xia, Ahmed E. Hassan, David Lo, Zhenchang Xing, and Xinyu Wang. 2018. Neural-Machine-Translation-Based Commit Message Generation: How Far Are We?. In 2018 33rd IEEE/ACM International Conference on Automated Software Engineering (ASE). 373-384.
  39. Zhongxin Liu, Xin Xia, David Lo, Meng Yan, and Shanping Li. 2021. Just-In- Time Obsolete Comment Detection and Update. IEEE Transactions on Software Engineering (2021).
  40. Zhongxin Liu, Xin Xia, Meng Yan, and Shanping Li. 2020. Automating Just- In-Time Comment Updating. In Proceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. ACM.
  41. Shuai Lu, Daya Guo, Shuo Ren, Junjie Huang, Alexey Svyatkovskiy, Ambro- sio Blanco, Colin Clement, Dawn Drain, Daxin Jiang, Duyu Tang, et al. 2021. CodeXGLUE: A Machine Learning Benchmark Dataset for Code Understand- ing and Generation. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 1).
  42. Shane McIntosh and Yasutaka Kamei. 2018. Are Fix-Inducing Changes a Moving Target? A Longitudinal Case Study of Just-In-Time Defect Prediction. IEEE Transactions on Software Engineering 44, 5 (2018), 412-428.
  43. Audris Mockus and Lawrence G Votta. 2000. Identifying Reasons for Software Changes using Historic Databases. In Proceedings of the 16th International Con- ference on Software Maintenance. IEEE, 120-130. https://doi.org/10.1109/ICSM. 2000.883028 · DOI
  44. Courtney Napoles, Keisuke Sakaguchi, Matt Post, and Joel Tetreault. 2015. Ground truth for grammatical error correction metrics. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 2: Short Papers). 588- 593.
  45. Tung Thanh Nguyen, Hoan Anh Nguyen, Nam H Pham, Jafar M Al-Kofahi, and Tien N Nguyen. 2009. Clone-aware configuration management. In 2009 IEEE/ACM International Conference on Automated Software Engineering. IEEE, 123-134.
  46. Chao Ni, Wei Wang, Kaiwen Yang, Xin Xia, Kui Liu, and David Lo. 2022. The Best of Both Worlds: Integrating Semantic Features with Expert Features for Defect Pre- diction and Localization. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (Singapore, Singapore) (ESEC/FSE 2022). Association for Computing Machinery, New York, NY, USA, 672-683. https://doi.org/10.1145/3540250.3549165 · DOI
  47. Profir-Petru Pârt ,achi, Santanu Kumar Dash, Miltiadis Allamanis, and Earl T Barr. 2020. Flexeme: Untangling commits using lexical flows. In Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 63-74.
  48. Dewayne E Perry, Harvey P Siy, and Lawrence G Votta. 2001. Parallel changes in large-scale software development: an observational case study. ACM Transactions on Software Engineering and Methodology (TOSEM) 10, 3 (2001), 308-337.
  49. Chanathip Pornprasit and Chakkrit Kla Tantithamthavorn. 2021. Jitline: A simpler, better, faster, finer-grained just-in-time defect prediction. In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR). IEEE, 369-379.
  50. Ranjith Purushothaman and Dewayne E Perry. 2005. Toward understanding the rhetoric of small source code changes. IEEE Transactions on Software Engineering 31, 6 (2005), 511-526.
  51. Sarah Rastkar and Gail C Murphy. 2013. Why did this code change?. In 2013 35th International Conference on Software Engineering (ICSE). IEEE, 1193-1196.
  52. Hinrich Schütze, Christopher D Manning, and Prabhakar Raghavan. 2008. Intro- duction to information retrieval. Vol. 39. Cambridge University Press Cambridge.
  53. Emad Shihab, Ahmed E Hassan, Bram Adams, and Zhen Ming Jiang. 2012. An industrial study on the risk of software changes. In Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering. 1-11.
  54. Shivkumar Shivaji, E James Whitehead, Ram Akella, and Sunghun Kim. 2012. Re- ducing features to improve code change-based bug prediction. IEEE Transactions on Software Engineering 39, 4 (2012), 552-569.
  55. Jonathan Sillito, Gail C Murphy, and Kris De Volder. 2008. Asking and answering questions during a programming change task. IEEE Transactions on Software Engineering 34, 4 (2008), 434-451.
  56. Zhensu Sun, Li Li, Yan Liu, Xiaoning Du, and Li Li. 2022. On the Importance of Building High-quality Training Datasets for Neural Code Search. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE). ACM.
  57. Wei Tao, Yanlin Wang, Ensheng Shi, Lun Du, Shi Han, Hongyu Zhang, Dongmei Zhang, and Wenqiang Zhang. 2022. A large-scale empirical study of commit mes- sage generation: models, datasets and evaluation. Empirical Software Engineering 27, 7 (2022), 1-43.
  58. Yida Tao, Yingnong Dang, Tao Xie, Dongmei Zhang, and Sunghun Kim. 2012. How do software engineers understand code changes? An exploratory study in industry. In Proceedings of the ACM SIGSOFT 20th International symposium on the foundations of software engineering. 1-11.
  59. Yao Wan, Jingdong Shu, Yulei Sui, Guandong Xu, Zhou Zhao, Jian Wu, and Philip Yu. 2019. Multi-modal attention network learning for semantic source code retrieval. In 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 13-25.
  60. Chaozheng Wang, Yuanhang Yang, Cuiyun Gao, Yun Peng, Hongyu Zhang, and Michael R. Lyu. 2022. No More Fine-Tuning? An Experimental Evaluation of Prompt Tuning in Code Intelligence. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (Singapore, Singapore) (ESEC/FSE 2022). Association for Computing Machinery, New York, NY, USA, 382-394. https://doi.org/10.1145/ 3540250.3549113 · DOI
  61. Haoye Wang, Xin Xia, David Lo, Qiang He, Xinyu Wang, and John Grundy. 2021. Context-aware retrieval-based deep commit message Generation. ACM Transactions on Software Engineering and Methodology (TOSEM) 30, 4 (2021), 1-30.
  62. Song Wang, Taiyue Liu, and Lin Tan. 2016. Automatically learning semantic features for defect prediction. In Proceedings of the 38th International Conference on Software Engineering. ACM, 297-308. https://doi.org/10.1145/2884781.2884804 · DOI
  63. Shangwen Wang, Ming Wen, Bo Lin, Hongjun Wu, Yihao Qin, Deqing Zou, Xiaoguang Mao, and Hai Jin. 2020. Automated Patch Correctness Assessment: How Far are We?. In Proceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. ACM.
  64. Wenhan Wang, Ge Li, Bo Ma, Xin Xia, and Zhi Jin. 2020. Detecting code clones with graph neural network and flow-augmented abstract syntax tree. In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 261-271.
  65. F. Wilcoxon. 1945. Individual Comparisons by Ranking Methods. Biometrics Bulletin 1, 6 (1945), 80-83.
  66. Yu Wu, Jessica Kropcznyski, Raquel Prates, and John M Carroll. 2015. The rise of curation on GitHub. In Third AAAI conference on human computation and crowdsourcing.
  67. Shengbin Xu, Yuan Yao, Feng Xu, Tianxiao Gu, Hanghang Tong, and Jian Lu. 2019. Commit message generation for source code changes. In IJCAI.
  68. Pengcheng Yin and Graham Neubig. 2018. TRANX: A Transition-based Neural Abstract Syntax Parser for Semantic Parsing and Code Generation. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing: System Demonstrations. 7-12.
  69. Pengcheng Yin, Graham Neubig, Miltiadis Allamanis, Marc Brockschmidt, and Alexander L Gaunt. 2018. Learning to Represent Edits. In International Conference on Learning Representations.
  70. Jiyang Zhang, Sheena Panthaplackel, Pengyu Nie, Junyi Jessy Li, and Milos Glig- oric. 2022. CoditT5: Pretraining for Source Code and Natural Language Editing. In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering. ACM.
  71. Michael Zhivich and Robert K Cunningham. 2009. The real cost of software errors. IEEE Security & Privacy 7, 2 (2009), 87-90.
  72. Yaqin Zhou, Shangqing Liu, Jingkai Siow, Xiaoning Du, and Yang Liu. 2019. Devign: Effective vulnerability identification by learning comprehensive program semantics via graph neural networks. Advances in neural information processing systems 32 (2019).

Cited by

Sorted by citations

Authors
Lin, B., Wang, S., Liu, Z., Liu, Y., Xia, X., & Mao, X.
Affiliations
  • National University of Defense Technology (CN)
  • Zhejiang University (CN)
  • Southern University of Science and Technology (CN)
ORCID
Venue
Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering
Publisher
ACM
Published
2023-11-30
Pages
1509-1521
DOI
10.1145/3611643.3616339
OpenAlex
W4389162095
Cited by
69
References
9
Citations by year
2026: 18 · 2025: 30 · 2024: 21
FWCI
17.73
Type
conference paper
Language
en
Open access
Licence
www.acm.org/publications/policies/copyright_policy#Background (vor)
Locations
  • ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) (publishedVersion)
  • arXiv (Cornell University) (submittedVersion)
  • arXiv (Cornell University)
Funders
  • National Natural Science Foundation of China (61932021,62202420)
  • Zhejiang University Education Foundation Qizhen Scholar Foundation
Topics
  • Physical Sciences › Computer Science › Information Systems › Software Engineering Research
  • Physical Sciences › Computer Science › Artificial Intelligence › Topic Modeling
  • Physical Sciences › Computer Science › Information Systems › Software Engineering Techniques and Practices
Keywords
CCT5, commit message generation, code review, software maintenance, pre-trained language models, fine-tuning

About these checks

Registry, retraction, Cites and statistics results are computed, not judged, with one exception: a printed reference that no index lists is read once by a model before it counts as a citation error. Claims are extracted by a model and kept only when their quote appears verbatim in the text; each cited source is then checked, with a model’s help, for whether it says what the claim relies on. Those verdicts can be wrong — read the claim’s quote and the cited source before relying on one.

Statistics and arithmetic are recomputed, not judged.

Confidence bands are shown only for fields calibrated on our annotated test set. None is calibrated yet, so no band is shown.

What counts as a claim ›How we measure confidence ›How we check this ›

Are you an author, or do you see a problem with this page? Request a review