* Malhotra and Jain (2012) Ruchika Malhotra and Ankita Jain. 2012.  Fault prediction using statistical and machine learning methods for improving software quality.  _Journal of Information Processing Systems_ 8, 2 (2012), 241–262.
  * Malhotra and Jangra (2017) R. Malhotra and Rupender Jangra. 2017.  Prediction & Assessment of Change Prone Classes Using Statistical & Machine Learning Techniques.  _Journal of Information Processing Systems_ 13 (01 2017), 778–804.  https://doi.org/10.3745/JIPS.04.0013
  * Malhotra and Kamal (2019) Ruchika Malhotra and Shine Kamal. 2019.  An empirical study to investigate oversampling methods for improving software defect prediction using imbalanced data.  _Neurocomputing_ 343 (2019), 120–140.
  * Malhotra and Khanna (2013) Ruchika Malhotra and Megha Khanna. 2013.  Investigation of relationship between object-oriented metrics and change proneness.  _International Journal of Machine Learning and Cybernetics_ 4, 4 (2013), 273–286.
  * Malhotra and Singh (2011) Ruchika Malhotra and Yogesh Singh. 2011.  On the applicability of machine learning techniques for object-oriented software fault prediction.  _Software Engineering: An International Journal_ 1 (01 2011).
  * Malhotra1 and Chug (2012) Ruchika Malhotra1 and Anuradha Chug. 2012.  Software maintainability prediction using machine learning algorithms.  _Software engineering: an international Journal (SeiJ)_ 2, 2 (2012).
  * Malik et al. (2019) R. S. Malik, J. Patra, and M. Pradel. 2019\.  NL2Type: Inferring JavaScript Function Types from Natural Language Information. In _2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE)_. 304–315.  https://doi.org/10.1109/ICSE.2019.00045
  * Manjula and Florence (2019) C Manjula and Lilly Florence. 2019.  Deep neural network based hybrid approach for software defect prediction using software metrics.  _Cluster Computing_ 22, 4 (2019), 9847–9863.
  * Mariano et al. (2021) Richard VR Mariano, Geanderson E dos Santos, and Wladmir Cardoso Brandao. 2021.  Improve Classification of Commits Maintenance Activities with Quantitative Changes in Source Code.  (2021).
  * Mariano et al. (2019) Richard VR Mariano, Geanderson E dos Santos, Markos V de Almeida, and Wladmir C Brand
textasciitilde ao. 2019\.  Feature changes in source code for commit
classification into maintenance activities. In _2019 18th IEEE International
Conference On Machine Learning And Applications (ICMLA)_. IEEE, 515–518.

  * Mashhadi and Hemmati (2021) Ehsan Mashhadi and Hadi Hemmati. 2021.  Applying codebert for automated program repair of java simple bugs. In _2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR)_. IEEE, 505–509.
  * Mateless et al. (2020) Roni Mateless, Daniel Rejabek, Oded Margalit, and Robert Moskovitch. 2020.  Decompiled APK based malicious code classification.  _Future Generation Computer Systems_ 110 (2020), 135–147.  https://doi.org/10.1016/j.future.2020.03.052
  * McCabe (1976) Thomas J McCabe. 1976\.  A complexity measure.  _IEEE Transactions on software Engineering_ 4 (1976), 308–320.
  * Medeiros et al. (2016) Ibéria Medeiros, Nuno Neves, and Miguel Correia. 2016\.  Detecting and Removing Web Application Vulnerabilities with Static Analysis and Data Mining.  _IEEE Transactions on Reliability_ 65, 1 (2016), 54–69.  https://doi.org/10.1109/TR.2015.2457411
  * Medeiros et al. (2013) Iberia Medeiros, Nuno F. Neves, and Miguel Correia. 2013\.  Securing energy metering software with automatic source code correction. In _2013 11th IEEE International Conference on Industrial Informatics (INDIN)_.  https://doi.org/10.1109/indin.2013.6622969
  * Medeiros et al. (2014) Ibéria Medeiros, Nuno F. Neves, and Miguel Correia. 2014\.  Automatic Detection and Correction of Web Application Vulnerabilities Using Data Mining to Predict False Positives. In _Proceedings of the 23rd International Conference on World Wide Web_ (Seoul, Korea) _(WWW ’14)_. 63–74.  https://doi.org/10.1145/2566486.2568024
  * Meng et al. (2021) Na Meng, Zijian Jiang, and Hao Zhong. 2021.  Classifying Code Commits with Convolutional Neural Networks. In _2021 International Joint Conference on Neural Networks (IJCNN)_. IEEE, 1–8.
  * Meqdadi et al. (2019) Omar Meqdadi, Nouh Alhindawi, Jamal Alsakran, Ahmad Saifan, and Hatim Migdadi. 2019.  Mining software repositories for adaptive change commits using machine learning techniques.  _Information and Software Technology_ 109 (2019), 80 – 91.  https://doi.org/10.1016/j.infsof.2019.01.008
  * Mesbah et al. (2019) Ali Mesbah, Andrew Rice, Emily Johnston, Nick Glorioso, and Edward Aftandilian. 2019.  DeepDelta: Learning to Repair Compilation Errors. In _Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering_ (Tallinn, Estonia) _(ESEC/FSE 2019)_. 925–936.  https://doi.org/10.1145/3338906.3340455
  * Mhawish and Gupta (2020) Mohammad Y. Mhawish and Manjari Gupta. 2020.  Predicting Code Smells and Analysis of Predictions: Using Machine Learning Techniques and Software Metrics.  _J. Comput. Sci. Technol._ 35 (2020), 1428–1445.
  * Milosevic et al. (2017) Nikola Milosevic, Ali Dehghantanha, and Kim-Kwang Raymond Choo. 2017\.  Machine learning aided Android malware classification.  _Computers & Electrical Engineering_ 61 (2017), 266 – 274.  https://doi.org/10.1016/j.compeleceng.2017.02.013
  * Moskovitch et al. (2009) Robert Moskovitch, Nir Nissim, and Yuval Elovici. 2009\.  Malicious Code Detection Using Active Learning. In _Privacy, Security, and Trust in KDD_ , Francesco Bonchi, Elena Ferrari, Wei Jiang, and Bradley Malin (Eds.). 74–91.
  * Mostaeen et al. (2020) Golam Mostaeen, Banani Roy, Chanchal K. Roy, Kevin Schneider, and Jeffrey Svajlenko. 2020.  A machine learning based framework for code clone validation.  _Journal of Systems and Software_ 169 (2020), 110686.  https://doi.org/10.1016/j.jss.2020.110686
  * Mostaeen et al. (2018) Golam Mostaeen, Jeffrey Svajlenko, Banani Roy, Chanchal Roy, and Kevin Schneider. 2018.  [Research Paper] On the Use of Machine Learning Techniques Towards the Design of Cloud Based Automatic Code Clone Validation Tools. 155–164.  https://doi.org/10.1109/SCAM.2018.00025
  * Mostaeen et al. (2018) G. Mostaeen, J. Svajlenko, B. Roy, C. K. Roy, and K. A. Schneider. 2018.  [Research Paper] On the Use of Machine Learning Techniques Towards the Design of Cloud Based Automatic Code Clone Validation Tools. In _2018 IEEE 18th International Working Conference on Source Code Analysis and Manipulation (SCAM)_. 155–164.  https://doi.org/10.1109/SCAM.2018.00025
  * Mostaeen et al. (2019) Golam Mostaeen, Jeffrey Svajlenko, Banani Roy, Chanchal K. Roy, and Kevin A. Schneider. 2019.  CloneCognition: Machine Learning Based Code Clone Validation Tool. In _Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering_ (Tallinn, Estonia) _(ESEC/FSE 2019)_. 1105–1109.  https://doi.org/10.1145/3338906.3341182
  * Mou et al. (2016) Lili Mou, Ge Li, Lu Zhang, Tao Wang, and Zhi Jin. 2016.  Convolutional Neural Networks over Tree Structures for Programming Language Processing. In _Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence_ (Phoenix, Arizona) _(AAAI’16)_. 1287–1293.
  * Movshovitz-Attias and Cohen (2013) Dana Movshovitz-Attias and William Cohen. 2013.  Natural Language Models for Predicting Programming Comments.  _ACL 2013 - 51st Annual Meeting of the Association for Computational Linguistics, Proceedings of the Conference_ 2 (08 2013), 35–40.
  * Nair et al. (2019) Aravind Nair, Karl Meinke, and Sigrid Eldh. 2019\.  Leveraging Mutants for Automatic Prediction of Metamorphic Relations Using Machine Learning. In _Proceedings of the 3rd ACM SIGSOFT International Workshop on Machine Learning Techniques for Software Quality Evaluation_ (Tallinn, Estonia) _(MaLTeSQuE 2019)_. 1–6.  https://doi.org/10.1145/3340482.3342741
  * Narayanan et al. (2018) Annamalai Narayanan, Mahinthan Chandramohan, Lihui Chen, and Yang Liu. 2018.  A Multi-View Context-Aware Approach to Android Malware Detection and Malicious Code Localization.  _Empirical Softw. Engg._ 23, 3 (jun 2018), 1222–1274.  https://doi.org/10.1007/s10664-017-9539-8
  * Nazar et al. (2016) N. Nazar, Y. Hu, and He Jiang. 2016.  Summarizing Software Artifacts: A Literature Review.  _Journal of Computer Science and Technology_ 31 (2016), 883–909.
  * Nazar et al. (2015) N. Nazar, He Jiang, Guojun Gao, Tao Zhang, Xiaochen Li, and Zhilei Ren. 2015\.  Source code fragment summarization with small-scale crowdsourcing based features.  _Frontiers of Computer Science_ 10 (2015), 504–517.
  * Ndichu et al. (2019) Samuel Ndichu, Sangwook Kim, Seiichi Ozawa, Takeshi Misu, and Kazuo Makishima. 2019.  A machine learning approach to detection of JavaScript-based attacks using AST features and paragraph vectors.  _Applied Soft Computing_ 84 (2019), 105721.  https://doi.org/10.1016/j.asoc.2019.105721
  * Nguyen et al. (2018) A. T. Nguyen, T. D. Nguyen, H. D. Phan, and T. N. Nguyen. 2018.  A deep neural network language model with contexts for source code. In _2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER)_. 323–334.  https://doi.org/10.1109/SANER.2018.8330220
  * Nguyen et al. (2019) Duc-Man Nguyen, Hoang-Nhat Do, Quyet-Thang Huynh, Dinh-Thien Vo, and Nhu-Hang Ha. 2019.  Shinobi: A Novel Approach for Context-Driven Testing (CDT) Using Heuristics and Machine Learning for Web Applications. In _Industrial Networks and Intelligent Systems_ , Trung Q Duong and Nguyen-Son Vo (Eds.). 86–102.
  * Nguyen et al. (2013) Tung Thanh Nguyen, Anh Tuan Nguyen, Hoan Anh Nguyen, and Tien N. Nguyen. 2013.  A Statistical Semantic Language Model for Source Code. In _Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering_ (Saint Petersburg, Russia) _(ESEC/FSE 2013)_. Association for Computing Machinery, New York, NY, USA, 532–542.  https://doi.org/1086_Nguyen2013
  * Nie et al. (2021) Lun Yiu Nie, Cuiyun Gao, Zhicong Zhong, Wai Lam, Yang Liu, and Zenglin Xu. 2021\.  CoreGen: Contextualized Code Representation Learning for Commit Message Generation.  _Neurocomputing_ 459 (2021), 97–107.
  * Nyamawe et al. (2019) A. S. Nyamawe, H. Liu, N. Niu, Q. Umer, and Z. Niu. 2019.  Automated Recommendation of Software Refactorings Based on Feature Requests. In _2019 IEEE 27th International Requirements Engineering Conference (RE)_. 187–198.  https://doi.org/10.1109/RE.2019.00029
  * Nyamawe et al. (2020) Ally S. Nyamawe, Hui Liu, Nan Niu, Qasim Umer, and Zhendong Niu. 2020.  Feature Requests-Based Recommendation of Software Refactorings.  _Empirical Softw. Engg._ 25, 5 (sep 2020), 4315–4347.  https://doi.org/10.1007/s10664-020-09871-2
  * Ochodek et al. (2019) Miroslaw Ochodek, Regina Hebig, Wilhelm Meding, Gert Frost, and Miroslaw Staron. 2019.  Recognizing lines of code violating company-specific coding guidelines using machine learning.  _Empirical Software Engineering_ 25 (2019), 220–265.
  * Oda et al. (2015) Y. Oda, H. Fudaba, G. Neubig, H. Hata, S. Sakti, T. Toda, and S. Nakamura. 2015.  Learning to Generate Pseudo-Code from Source Code Using Statistical Machine Translation. In _2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE)_. 574–584.  https://doi.org/10.1109/ASE.2015.36
  * Okutan and Yıldız (2014) Ahmet Okutan and Olcay Taner Yıldız. 2014.  Software defect prediction using Bayesian networks.  _Empirical Software Engineering_ 19, 1 (2014), 154–181.
  * Oliveira et al. (2020) Daniel Oliveira, Wesley K. G. Assunção, Leonardo Souza, Willian Oizumi, Alessandro Garcia, and Baldoino Fonseca. 2020.  Applying Machine Learning to Customized Smell Detection: A Multi-Project Study _(SBES ’20)_. 233–242.  https://doi.org/10.1145/3422392.3422427
  * Omri and Sinz (2020) Safa Omri and Carsten Sinz. 2020.  Deep Learning for Software Defect Prediction: A Survey. In _Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops_ (Seoul, Republic of Korea) _(ICSEW’20)_. 209–214.  https://doi.org/10.1145/3387940.3391463
  * Padmanabhuni and Tan (2015) Bindu Madhavi Padmanabhuni and Hee Beng Kuan Tan. 2015.  Buffer Overflow Vulnerability Prediction from x86 Executables Using Static Analysis and Machine Learning. In _2015 IEEE 39th Annual Computer Software and Applications Conference_ , Vol. 2. 450–459.  https://doi.org/10.1109/COMPSAC.2015.78
  * Palomba et al. (2016) Fabio Palomba, Marco Zanoni, Francesca Arcelli Fontana, Andrea De Lucia, and Rocco Oliveto. 2016\.  Smells like teen spirit: Improving bug prediction performance using the intensity of code smells. In _2016 IEEE International Conference on Software Maintenance and Evolution (ICSME)_. IEEE, 244–255.
  * Palomba et al. (2017) Fabio Palomba, Marco Zanoni, Francesca Arcelli Fontana, Andrea De Lucia, and Rocco Oliveto. 2017\.  Toward a smell-aware bug prediction model.  _IEEE Transactions on Software Engineering_ 45, 2 (2017), 194–218.
  * Pan et al. (2019) Cong Pan, Minyan Lu, Biao Xu, and Houleng Gao. 2019\.  An improved CNN model for within-project software defect prediction.  _Applied Sciences_ 9, 10 (2019), 2138.
  * Pandey and Gupta (2018) A. K. Pandey and Manjari Gupta. 2018.  Software fault classification using extreme learning machine: a cognitive approach.  _Evolutionary Intelligence_ (2018), 1–8.
  * Pandey et al. (2021) Sushant Kumar Pandey, Ravi Bhushan Mishra, and Anil Kumar Tripathi. 2021.  Machine learning based methods for software fault prediction: A survey.  _Expert Systems with Applications_ 172 (2021), 114595.
  * Pang et al. (2016) Y. Pang, X. Xue, and A. S. Namin. 2016.  Early Identification of Vulnerable Software Components via Ensemble Learning. In _2016 15th IEEE International Conference on Machine Learning and Applications (ICMLA)_. 476–481.  https://doi.org/10.1109/ICMLA.2016.0084
  * Pang et al. (2017) Yulei Pang, Xiaozhen Xue, and Huaying Wang. 2017.  Predicting Vulnerable Software Components through Deep Neural Network. In _Proceedings of the 2017 International Conference on Deep Learning Technologies_ (Chengdu, China) _(ICDLT ’17)_. Association for Computing Machinery, New York, NY, USA, 6–10.  https://doi.org/10.1145/3094243.3094245
  * Panichella et al. (2012) Sebastiano Panichella, Jairo Aponte, Massimiliano Di Penta, Andrian Marcus, and Gerardo Canfora. 2012\.  Mining source code descriptions from developer communications. In _2012 20th IEEE International Conference on Program Comprehension (ICPC)_. 63–72.  https://doi.org/10.1109/ICPC.2012.6240510
  * Pascarella et al. (2018) Luca Pascarella, Fabio Palomba, and Alberto Bacchelli. 2018\.  Re-evaluating method-level bug prediction. In _2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER)_. IEEE, 592–601.
  * Patel et al. (2008) Kayur Patel, James Fogarty, James A. Landay, and Beverly Harrison. 2008.  Investigating Statistical Machine Learning as a Tool for Software Development. In _Proceedings of the SIGCHI Conference on Human Factors in Computing Systems_ (Florence, Italy) _(CHI ’08)_. 667–676.  https://doi.org/10.1145/1357054.1357160
  * Pecorelli et al. (2019) Fabiano Pecorelli, Dario Di Nucci, Coen De Roover, and Andrea De Lucia. 2019.  On the Role of Data Balancing for Machine Learning-Based Code Smell Detection. In _Proceedings of the 3rd ACM SIGSOFT International Workshop on Machine Learning Techniques for Software Quality Evaluation_ (Tallinn, Estonia) _(MaLTeSQuE 2019)_. 19–24.  https://doi.org/10.1145/3340482.3342744
  * Pecorelli et al. (2019) F. Pecorelli, F. Palomba, D. Di Nucci, and A. De Lucia. 2019.  Comparing Heuristic and Machine Learning Approaches for Metric-Based Code Smell Detection. In _2019 IEEE/ACM 27th International Conference on Program Comprehension (ICPC)_. 93–104.
  * Pereira et al. (2019) J. D. Pereira, J. R. Campos, and M. Vieira. 2019\.  An Exploratory Study on Machine Learning to Combine Security Vulnerability Alerts from Static Analysis Tools. In _2019 9th Latin-American Symposium on Dependable Computing (LADC)_. 1–10.  https://doi.org/10.1109/LADC48089.2019.8995685
  * Perl et al. (2015) Henning Perl, Sergej Dechand, Matthew Smith, Daniel Arp, Fabian Yamaguchi, Konrad Rieck, Sascha Fahl, and Yasemin Acar. 2015\.  VCCFinder: Finding Potential Vulnerabilities in Open-Source Projects to Assist Code Audits. In _Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security_ (Denver, Colorado, USA) _(CCS ’15)_. 426–437.  https://doi.org/10.1145/2810103.2813604
  * Phan and Jannesari (2020) Hung Phan and Ali Jannesari. 2020.  Statistical Machine Translation Outperforms Neural Machine Translation in Software Engineering: Why and How. In _Proceedings of the 1st ACM SIGSOFT International Workshop on Representation Learning for Software Engineering and Program Languages_ (Virtual, USA) _(RL+SE &PL 2020)_. 3–12.  https://doi.org/10.1145/3416506.3423576
  * Pinconschi et al. (2021) Eduard Pinconschi, Rui Abreu, and Pedro Ad
textasciitilde ao. 2021\.  A Comparative Study of Automatic Program Repair
Techniques for Security Vulnerabilities. In _2021 IEEE 32nd International
Symposium on Software Reliability Engineering (ISSRE)_. IEEE, 196–207.

  * Piskachev et al. (2019) Goran Piskachev, Lisa Nguyen Quang Do, and Eric Bodden. 2019\.  Codebase-Adaptive Detection of Security-Relevant Methods. In _Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis_ (Beijing, China) _(ISSTA 2019)_. 181–191.  https://doi.org/10.1145/3293882.3330556
  * Ponta et al. (2019) Serena E. Ponta, Henrik Plate, Antonino Sabetta, Michele Bezzi, and Cédric Dangremont. 2019\.  A Manually-Curated Dataset of Fixes to Vulnerabilities of Open-Source Software. In _Proceedings of the 16th International Conference on Mining Software Repositories_ (Montreal, Quebec, Canada) _(MSR ’19)_. 383–387.  https://doi.org/10.1109/MSR.2019.00064
  * Pour et al. (2021) Maryam Vahdat Pour, Zhuo Li, Lei Ma, and Hadi Hemmati. 2021\.  A search-based testing framework for deep neural networks of source code embedding. In _2021 14th IEEE Conference on Software Testing, Verification and Validation (ICST)_. IEEE, 36–46.
  * Prabha and Shivakumar (2020) C. L. Prabha and N. Shivakumar. 2020.  Software Defect Prediction Using Machine Learning Techniques. In _2020 4th International Conference on Trends in Electronics and Informatics (ICOEI)(48184)_. 728–733.  https://doi.org/10.1109/ICOEI48184.2020.9142909
  * Pradel and Sen (2018) Michael Pradel and Koushik Sen. 2018.  DeepBugs: A Learning Approach to Name-Based Bug Detection.  _Proc. ACM Program. Lang._ 2, OOPSLA, Article 147 (October 2018), 25 pages.  https://doi.org/10.1145/3276517
  * Premalatha and Srikrishna (2017) Hosahalli Mahalingappa Premalatha and Chimanahalli Venkateshavittalachar Srikrishna. 2017\.  Software Fault Prediction and Classification using Cost based Random Forest in Spiral Life Cycle Model.  _system_ 11 (2017).
  * Prince (2004) Michael Prince. 2004\.  Does active learning work? A review of the research.  _Journal of engineering education_ 93, 3 (2004), 223–231.
  * Pritam et al. (2019) N. Pritam, M. Khari, L. Hoang Son, R. Kumar, S. Jha, I. Priyadarshini, M. Abdel-Basset, and H. Viet Long. 2019\.  Assessment of Code Smell for Predicting Class Change Proneness Using Machine Learning.  _IEEE Access_ 7 (2019), 37414–37425.  https://doi.org/10.1109/ACCESS.2019.2905133
  * Proksch et al. (2015) Sebastian Proksch, Johannes Lerch, and Mira Mezini. 2015\.  Intelligent Code Completion with Bayesian Networks.  _ACM Trans. Softw. Eng. Methodol._ 25, 1, Article 3 (December 2015), 31 pages.  https://doi.org/10.1145/2744200
  * Psarras et al. (2019) Christos Psarras, Themistoklis Diamantopoulos, and Andreas Symeonidis. 2019.  A mechanism for automatically summarizing software functionality from source code. In _2019 IEEE 19th International Conference on Software Quality, Reliability and Security (QRS)_. IEEE, 121–130.
  * Qiao et al. (2020) Lei Qiao, Xuesong Li, Qasim Umer, and Ping Guo. 2020\.  Deep learning based software defect prediction.  _Neurocomputing_ 385 (2020), 100–110.
  * Rabin et al. (2020) Md Rafiqul Islam Rabin, Arjun Mukherjee, Omprakash Gnawali, and Mohammad Amin Alipour. 2020.  Towards Demystifying Dimensions of Source Code Embeddings. In _Proceedings of the 1st ACM SIGSOFT International Workshop on Representation Learning for Software Engineering and Program Languages_ (Virtual, USA) _(RL+SE &PL 2020)_. 29–38.  https://doi.org/10.1145/3416506.3423580
  * Rahman et al. (2017) Akond Rahman, Priysha Pradhan, Asif Partho, and Laurie Williams. 2017.  Predicting Android Application Security and Privacy Risk with Static Code Metrics. In _Proceedings of the 4th International Conference on Mobile Software Engineering and Systems_ (Buenos Aires, Argentina) _(MOBILESoft ’17)_. 149–153.  https://doi.org/10.1109/MOBILESoft.2017.14
  * Rahman et al. (2020) M. Rahman, Yutaka Watanobe, and K. Nakamura. 2020\.  A Neural Network Based Intelligent Support Model for Program Code Completion.  _Sci. Program._ 2020 (2020), 7426461:1–7426461:18.  https://doi.org/10.1155/2020/7426461
  * Rahman et al. (2015) M. M. Rahman, C. K. Roy, and I. Keivanloo. 2015.  Recommending Insightful Comments for Source Code using Crowdsourced Knowledge. In _Proc. SCAM_. 81–90.
  * Rathore and Kumar (2021) Santosh S Rathore and Sandeep Kumar. 2021.  Software fault prediction based on the dynamic selection of learning technique: findings from the eclipse project study.  _Applied Intelligence_ 51, 12 (2021), 8945–8960.
  * Raychev et al. (2016) Veselin Raychev, Pavol Bielik, and Martin Vechev. 2016\.  Probabilistic Model for Code with Decision Trees.  _SIGPLAN Not._ 51, 10 (October 2016), 731–747.  https://doi.org/10.1145/3022671.2984041
  * Reddivari and Raman (2019) Sandeep Reddivari and Jayalakshmi Raman. 2019.  Software quality prediction: an investigation based on machine learning. In _2019 IEEE 20th International Conference on Information Reuse and Integration for Data Science (IRI)_. IEEE, 115–122.
  * Ren et al. (2014) Jinsheng Ren, Ke Qin, Ying Ma, and Guangchun Luo. 2014\.  On software defect prediction using machine learning.  _Journal of Applied Mathematics_ 2014 (2014).
  * Ren et al. (2019) Jiadong Ren, Zhangqi Zheng, Qian Liu, Zhiyao Wei, and Huaizhi Yan. 2019.  A Buffer Overflow Prediction Approach Based on Software Metrics and Machine Learning.  _Security and Communication Networks_ 2019 (March 2019), e8391425.  https://doi.org/10.1155/2019/8391425 Publisher: Hindawi.
  * Ren et al. (2020) Pengzhen Ren, Yun Xiao, Xiaojun Chang, Po-Yao Huang, Zhihui Li, Xiaojiang Chen, and Xin Wang. 2020.  A survey of deep active learning.  _arXiv preprint arXiv:2009.00236_ (2020).
  * Renzullo et al. (2021) Joseph Renzullo, Westley Weimer, and Stephanie Forrest. 2021\.  Multiplicative Weights Algorithms for Parallel Automated Software Repair. In _2021 IEEE International Parallel and Distributed Processing Symposium (IPDPS)_. IEEE, 984–993.
  * Ribeiro et al. (2019) Athos Ribeiro, Paulo Meirelles, Nelson Lago, and Fabio Kon. 2019.  Ranking Warnings from Multiple Source Code Static Analyzers via Ensemble Learning. In _Proceedings of the 15th International Symposium on Open Collaboration_ (Skövde, Sweden) _(OpenSym ’19)_. Article 5, 10 pages.  https://doi.org/10.1145/3306446.3340828
  * Rodriguez et al. (2019) Guillermo Rodriguez, Cristian Mateos, Luciano Listorti, Brian Hammer, and Sanjay Misra. 2019\.  A Novel Unsupervised Learning Approach for Assessing Web Services Refactoring. In _Information and Software Technologies_ , Robertas Damaševičius and Giedrė Vasiljevienė (Eds.). 273–284.
  * Russell et al. (2018) R. Russell, L. Kim, L. Hamilton, T. Lazovich, J. Harer, O. Ozdemir, P. Ellingwood, and M. McConley. 2018\.  Automated Vulnerability Detection in Source Code Using Deep Representation Learning. In _2018 17th IEEE International Conference on Machine Learning and Applications (ICMLA)_. 757–762.  https://doi.org/10.1109/ICMLA.2018.00120
  * Russell et al. (2018) Rebecca Russell, Louis Kim, Lei Hamilton, Tomo Lazovich, Jacob Harer, Onur Ozdemir, Paul Ellingwood, and Marc McConley. 2018\.  Automated Vulnerability Detection in Source Code Using Deep Representation Learning. In _2018 17th IEEE International Conference on Machine Learning and Applications (ICMLA)_. 757–762.  https://doi.org/10.1109/ICMLA.2018.00120
  * Sabetta and Bezzi (2018) Antonino Sabetta and Michele Bezzi. 2018.  A practical approach to the automatic classification of security-relevant commits. In _2018 IEEE International conference on software maintenance and evolution (ICSME)_. IEEE, 579–582.
  * Saccente et al. (2019) N. Saccente, J. Dehlinger, L. Deng, S. Chakraborty, and Y. Xiong. 2019\.  Project Achilles: A Prototype Tool for Static Method-Level Vulnerability Detection of Java Source Code Using a Recurrent Neural Network. In _2019 34th IEEE/ACM International Conference on Automated Software Engineering Workshop (ASEW)_. 114–121.  https://doi.org/10.1109/ASEW.2019.00040
  * Sachdev et al. (2018) Saksham Sachdev, Hongyu Li, Sifei Luan, Seohyun Kim, Koushik Sen, and Satish Chandra. 2018\.  Retrieval on Source Code: A Neural Code Search. In _Proceedings of the 2nd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages_ (Philadelphia, PA, USA) _(MAPL 2018)_. 31–41.  https://doi.org/10.1145/3211346.3211353
  * Sagar et al. (2021) Priyadarshni Suresh Sagar, Eman Abdulah AlOmar, Mohamed Wiem Mkaouer, Ali Ouni, and Christian D. Newman. 2021.  Comparing Commit Messages and Source Code Metrics for the Prediction Refactoring Activities.  _Algorithms_ 14, 10 (2021).  https://doi.org/10.3390/733_Sagar2021
  * Saha et al. (2017) R. K. Saha, Y. Lyu, H. Yoshida, and M. R. Prasad. 2017\.  Elixir: Effective object-oriented program repair. In _2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE)_. 648–659.  https://doi.org/10.1109/ASE.2017.8115675
  * Saha et al. (2019) S. Saha, R. k. Saha, and M. r. Prasad. 2019.  Harnessing Evolution for Multi-Hunk Program Repair. In _2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE)_. 13–24.  https://doi.org/10.1109/ICSE.2019.00020
  * Saidani et al. (2020) Islem Saidani, Ali Ouni, and Mohamed Wiem Mkaouer. 2020\.  Web Service API Anti-patterns Detection as a Multi-label Learning Problem. In _International Conference on Web Services_. Springer, 114–132.
  * Sainath et al. (2015) Tara N Sainath, Brian Kingsbury, George Saon, Hagen Soltau, Abdel-rahman Mohamed, George Dahl, and Bhuvana Ramabhadran. 2015.  Deep convolutional neural networks for large-scale speech tasks.  _Neural Networks_ 64 (2015), 39–48.
  * Sakkas et al. (2020) Georgios Sakkas, Madeline Endres, Benjamin Cosman, Westley Weimer, and Ranjit Jhala. 2020.  Type Error Feedback via Analytic Program Repair. In _Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation_ (London, UK) _(PLDI 2020)_. 16–30.  https://doi.org/10.1145/3385412.3386005
  * Sankaran et al. (2017) Anush Sankaran, Rahul Aralikatte, Senthil Mani, Shreya Khare, Naveen Panwar, and Neelamadhav Gantayat. 2017.  DARVIZ: Deep Abstract Representation, Visualization, and Verification of Deep Learning Models.  _CoRR_ abs/1708.04915 (2017).  arXiv:1708.04915 http://arxiv.org/abs/1708.04915
  * Santos et al. (2018) E. A. Santos, J. C. Campbell, D. Patel, A. Hindle, and J. N. Amaral. 2018.  Syntax and sensibility: Using language models to detect and correct syntax errors. In _2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER)_. 311–322.  https://doi.org/10.1109/SANER.2018.8330219
  * Santos et al. (2013) Igor Santos, Jaime Devesa, Félix Brezo, Javier Nieves, and Pablo Garcia Bringas. 2013\.  OPEM: A Static-Dynamic Approach for Machine-Learning-Based Malware Detection. In _International Joint Conference CISIS’12-ICEUTE´12-SOCO´12 Special Sessions_ , Álvaro Herrero, Václav Snášel, Ajith Abraham, Ivan Zelinka, Bruno Baruque, Héctor Quintián, José Luis Calvo, Javier Sedano, and Emilio Corchado (Eds.). 271–280.
  * Sarro et al. (2012) F. Sarro, S. Di Martino, F. Ferrucci, and C. Gravino. 2012\.  A Further Analysis on the Use of Genetic Algorithm to Configure Support Vector Machines for Inter-Release Fault Prediction. In _Proceedings of the 27th Annual ACM Symposium on Applied Computing_ (Trento, Italy) _(SAC ’12)_. Association for Computing Machinery, New York, NY, USA, 1215–1220.  https://doi.org/10.1145/2245276.2231967
  * Sayyad Shirabad and Menzies (2005) J. Sayyad Shirabad and T.J. Menzies. 2005.  The PROMISE Repository of Software Engineering Databases.  School of Information Technology and Engineering, University of Ottawa, Canada.  http://promise.site.uottawa.ca/SERepository
  * Schumacher et al. (2020) Max Eric Henry Schumacher, Kim Tuyen Le, and Artur Andrzejak. 2020\.  Improving Code Recommendations by Combining Neural and Classical Machine Learning Approaches. In _Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops_ (Seoul, Republic of Korea) _(ICSEW’20)_. 476–482.  https://doi.org/10.1145/3387940.3391489
  * Schuster et al. (2021) R. Schuster, Congzheng Song, Eran Tromer, and Vitaly Shmatikov. 2021.  You Autocomplete Me: Poisoning Vulnerabilities in Neural Code Completion. In _30th USENIX Security Symposium (USENIX Security 21)_.
  * Sethi and Gagandeep (2016) T. Sethi and Gagandeep. 2016.  Improved approach for software defect prediction using artificial neural networks. In _2016 5th International Conference on Reliability, Infocom Technologies and Optimization (Trends and Future Directions) (ICRITO)_. 480–485.  https://doi.org/10.1109/ICRITO.2016.7785003
  * Settles (2009) Burr Settles. 2009\.  Active learning literature survey.  (2009).
  * Shabtai et al. (2009) Asaf Shabtai, Robert Moskovitch, Yuval Elovici, and Chanan Glezer. 2009.  Detection of malicious code by applying machine learning classifiers on static features: A state-of-the-art survey.  _Information Security Technical Report_ 14, 1 (2009), 16 – 29.  https://doi.org/10.1016/j.istr.2009.03.003 Malware.
  * Shar et al. (2015) L. K. Shar, L. C. Briand, and H. B. K. Tan. 2015\.  Web Application Vulnerability Prediction Using Hybrid Program Analysis and Machine Learning.  _IEEE Transactions on Dependable and Secure Computing_ 12, 6 (2015), 688–707.  https://doi.org/10.1109/TDSC.2014.2373377
  * Sharma (2018) Tushar Sharma. 2018\.  DesigniteJava.  https://doi.org/10.5281/zenodo.2566861 https://github.com/tushartushar/DesigniteJava.
  * Sharma (2019a) Tushar Sharma. 2019a.  CodeSplit for C#.  https://doi.org/10.5281/zenodo.2566905
  * Sharma (2019b) Tushar Sharma. 2019b.  CodeSplitJava.  https://doi.org/10.5281/zenodo.2566865 https://github.com/tushartushar/CodeSplitJava.
  * Sharma et al. (2021) Tushar Sharma, Vasiliki Efstathiou, Panos Louridas, and Diomidis Spinellis. 2021.  Code smell detection by deep direct-learning and transfer-learning.  _Journal of Systems and Software_ 176 (2021), 110936.  https://doi.org/10.1016/j.jss.2021.110936
  * Sharma et al. (2022) Tushar Sharma, Maria Kechagia, Stefanos Georgiou, Rohit Tiwari, Indira Vats, Hadi Moazen, and Federica Sarro. 2022.  _Replication package for Machine Learning for Source Code Analysis survey paper_.  https://github.com/tushartushar/ML4SCA
  * Sharma and Kessentini (2021) T. Sharma and M. Kessentini. 2021.  QScored: A Large Dataset of Code Smells and Quality Metrics. In _2021 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR) (MSR)_. IEEE Computer Society, Los Alamitos, CA, USA, 590–594.  https://doi.org/10.1109/MSR52588.2021.00080
  * Sharma et al. (2016) Tushar Sharma, Pratibha Mishra, and Rohit Tiwari. 2016\.  Designite — A Software Design Quality Assessment Tool. In _Proceedings of the First International Workshop on Bringing Architecture Design Thinking into Developers’ Daily Activities_ _(BRIDGE ’16)_.  https://doi.org/10.1145/2896935.2896938
  * Sharma and Spinellis (2018) Tushar Sharma and Diomidis Spinellis. 2018.  A survey on software smells.  _Journal of Systems and Software_ 138 (2018), 158–173.  https://doi.org/10.1016/j.jss.2017.12.034
  * Shedko et al. (2020) Andrey Shedko, Ilya Palachev, Andrey Kvochko, Aleksandr Semenov, and Kwangwon Sun. 2020\.  Applying Probabilistic Models to C++ Code on an Industrial Scale. In _Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops_ (Seoul, Republic of Korea) _(ICSEW’20)_. 595–602.  https://doi.org/10.1145/3387940.3391477
  * Shen and Chen (2020) Zhidong Shen and S. Chen. 2020.  A Survey of Automatic Software Vulnerability Detection, Program Repair, and Defect Prediction Techniques.  _Secur. Commun. Networks_ 2020 (2020), 8858010:1–8858010:16.
  * Sheneamer and Kalita (2016) A. Sheneamer and J. Kalita. 2016.  Semantic Clone Detection Using Machine Learning. In _2016 15th IEEE International Conference on Machine Learning and Applications (ICMLA)_. 1024–1028.  https://doi.org/10.1109/ICMLA.2016.0185
  * Shi et al. (2020) Ke Shi, Yang Lu, Jingfei Chang, and Zhen Wei. 2020\.  PathPair2Vec: An AST path pair-based code representation method for defect prediction.  _Journal of Computer Languages_ 59 (2020), 100979.  https://doi.org/10.1016/j.cola.2020.100979
  * Shido et al. (2019) Y. Shido, Y. Kobayashi, A. Yamamoto, A. Miyamoto, and T. Matsumura. 2019\.  Automatic Source Code Summarization with Extended Tree-LSTM. In _2019 International Joint Conference on Neural Networks (IJCNN)_. 1–8.  https://doi.org/10.1109/IJCNN.2019.8851751
  * Shim et al. (2020) S. Shim, P. Patil, R. R. Yadav, A. Shinde, and V. Devale. 2020.  DeeperCoder: Code Generation Using Machine Learning. In _2020 10th Annual Computing and Communication Workshop and Conference (CCWC)_. 0194–0199.  https://doi.org/10.1109/CCWC47524.2020.9031149
  * Shimonaka et al. (2016) K. Shimonaka, S. Sumi, Y. Higo, and S. Kusumoto. 2016\.  Identifying Auto-Generated Code by Using Machine Learning Techniques. In _2016 7th International Workshop on Empirical Software Engineering in Practice (IWESEP)_. 18–23.  https://doi.org/10.1109/IWESEP.2016.18
  * Shiqi et al. (2018) L. Shiqi, T. Shengwei, Y. Long, Y. Jiong, and S. Hua. 2018.  Android malicious code Classification using Deep Belief Network.  _KSII Transactions on Internet and Information Systems_ 12 (Jan. 2018), 454–475.  https://doi.org/10.3837/tiis.2018.01.022
  * Shuai et al. (2020) Jianhang Shuai, Ling Xu, Chao Liu, Meng Yan, Xin Xia, and Yan Lei. 2020.  Improving Code Search with Co-Attentive Representation Learning. In _Proceedings of the 28th International Conference on Program Comprehension_ (Seoul, Republic of Korea) _(ICPC ’20)_. 196–207.  https://doi.org/10.1145/3387904.3389269
  * Sidhu et al. (2022) Brahmaleen Kaur Sidhu, Kawaljeet Singh, and Neeraj Sharma. 2022\.  A machine learning approach to software model refactoring.  _International Journal of Computers and Applications_ 44, 2 (2022), 166–177.  https://doi.org/10.1080/1206212X.2020.1711616 arXiv:https://doi.org/10.1080/1206212X.2020.1711616
  * Singh et al. (2018) Ajmer Singh, Rajesh Bhatia, and Anita Singhrova. 2018\.  Taxonomy of machine learning algorithms in software fault prediction using object oriented metrics.  _Procedia computer science_ 132 (2018), 993–1001.
  * Singh and Chug (2017) P. Singh and A. Chug. 2017.  Software defect prediction analysis using machine learning algorithms. In _2017 7th International Conference on Cloud Computing, Data Science Engineering - Confluence_. 775–781.  https://doi.org/10.1109/CONFLUENCE.2017.7943255
  * Singh and Malhotra (2017) P. Singh and R. Malhotra. 2017.  Assessment of machine learning algorithms for determining defective classes in an object-oriented software. In _2017 6th International Conference on Reliability, Infocom Technologies and Optimization (Trends and Future Directions) (ICRITO)_. 204–209.  https://doi.org/10.1109/ICRITO.2017.8342425
  * Singh et al. (2020) R. Singh, J. Singh, M. S. Gill, R. Malhotra, and Garima. 2020.  Transfer Learning Code Vectorizer based Machine Learning Models for Software Defect Prediction. In _2020 International Conference on Computational Performance Evaluation (ComPE)_. 497–502.  https://doi.org/10.1109/ComPE49325.2020.9200076
  * Soltanifar et al. (2016) Behjat Soltanifar, Shirin Akbarinasaji, Bora Caglayan, Ayse Basar Bener, Asli Filiz, and Bryan M Kramer. 2016.  Software analytics in practice: a defect prediction model using code smells. In _Proceedings of the 20th International Database Engineering & Applications Symposium_. 148–155.
  * Song et al. (2019) Qinbao Song, Yuchen Guo, and Martin Shepperd. 2019.  A Comprehensive Investigation of the Role of Imbalanced Learning for Software Defect Prediction.  _IEEE Transactions on Software Engineering_ 45, 12 (2019), 1253–1269.  https://doi.org/10.1109/TSE.2018.2836442
  * Soto and Le Goues (2018) M. Soto and C. Le Goues. 2018.  Common Statement Kind Changes to Inform Automatic Program Repair. In _2018 IEEE/ACM 15th International Conference on Mining Software Repositories (MSR)_. 102–105.
  * Sotto-Mayor and Kalech (2021) Bruno Sotto-Mayor and Meir Kalech. 2021.  Cross-project smell-based defect prediction.  _Soft Computing_ 25, 22 (2021), 14171–14181.
  * Spreitzenbarth et al. (2014) Michael Spreitzenbarth, Thomas Schreck, F. Echtler, D. Arp, and Johannes Hoffmann. 2014\.  Mobile-Sandbox: combining static and dynamic analysis with machine-learning techniques.  _International Journal of Information Security_ 14 (2014), 141–153.
  * Stapleton et al. (2020) Sean Stapleton, Yashmeet Gambhir, Alexander LeClair, Zachary Eberhart, Westley Weimer, Kevin Leach, and Yu Huang. 2020.  A Human Study of Comprehension and Code Summarization. In _Proceedings of the 28th International Conference on Program Comprehension_ (Seoul, Republic of Korea) _(ICPC ’20)_. 2–13.  https://doi.org/10.1145/3387904.3389258
  * Storey (2005) M.-A. Storey. 2005\.  Theories, methods and tools in program comprehension: past, present and future. In _13th International Workshop on Program Comprehension (IWPC’05)_. 181–191.  https://doi.org/10.1109/WPC.2005.38
  * Sui et al. (2020) Yulei Sui, Xiao Cheng, Guanqin Zhang, and Haoyu Wang. 2020\.  Flow2Vec: Value-Flow-Based Precise Code Embedding.  _Proc. ACM Program. Lang._ 4, OOPSLA, Article 233 (November 2020), 27 pages.  https://doi.org/10.1145/3428301
  * Sui and Xue (2016) Yulei Sui and Jingling Xue. 2016.  SVF: interprocedural static value-flow analysis in LLVM. In _Proceedings of the 25th international conference on compiler construction_. ACM, 265–266.
  * Sultana (2017) Kazi Zakia Sultana. 2017\.  Towards a software vulnerability prediction model using traceable code patterns and software metrics. In _2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE)_. 1022–1025.  https://doi.org/10.1109/ASE.2017.8115724
  * Sultana et al. (2021) Kazi Zakia Sultana, Vaibhav Anu, and Tai-Yin Chong. 2021\.  Using software metrics for predicting vulnerable classes and methods in Java projects: A machine learning approach.  _Journal of Software: Evolution and Process_ 33, 3 (2021), e2303.  https://doi.org/10.1002/smr.2303
  * Sun et al. (2012) Zhongbin Sun, Qinbao Song, and Xiaoyan Zhu. 2012.  Using coding-based ensemble learning to improve software defect prediction.  _IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews)_ 42, 6 (2012), 1806–1817.
  * Suresh et al. (2014) Yeresime Suresh, Lov Kumar, and Santanu Ku Rath. 2014\.  Statistical and machine learning methods for software fault prediction using CK metric suite: a comparative analysis.  _International Scholarly Research Notices_ 2014 (2014).
  * Suryanarayana et al. (2014) Girish Suryanarayana, Ganesh Samarthyam, and Tushar Sharma. 2014\.  _Refactoring for Software Design Smells: Managing Technical Debt_ (1 ed.).  Morgan Kaufmann.
  * Svajlenko et al. (2014) Jeffrey Svajlenko, Judith F. Islam, Iman Keivanloo, Chanchal K. Roy, and Mohammad Mamun Mia. 2014.  Towards a Big Data Curated Benchmark of Inter-project Code Clones. In _2014 IEEE International Conference on Software Maintenance and Evolution_. 476–480.  https://doi.org/10.1109/ICSME.2014.77
  * Svyatkovskiy et al. (2020) Alexey Svyatkovskiy, Shao Kun Deng, Shengyu Fu, and Neel Sundaresan. 2020.  IntelliCode Compose: Code Generation Using Transformer. In _Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering_ (Virtual Event, USA) _(ESEC/FSE 2020)_. 1433–1443.  https://doi.org/10.1145/3368089.3417058
  * Svyatkovskiy et al. (2021) Alexey Svyatkovskiy, Sebastian Lee, Anna Hadjitofi, Maik Riechert, Juliana Vicente Franco, and Miltiadis Allamanis. 2021\.  Fast and memory-efficient neural code completion. In _2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR)_. IEEE, 329–340.
  * Svyatkovskiy et al. (2019) Alexey Svyatkovskiy, Ying Zhao, Shengyu Fu, and Neel Sundaresan. 2019.  Pythia: AI-Assisted Code Completion System. In _Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining_ (Anchorage, AK, USA) _(KDD ’19)_. 2727–2735.  https://doi.org/10.1145/3292500.3330699
  * Szegedy et al. (2015) Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. 2015.  Going deeper with convolutions. In _Proceedings of the IEEE conference on computer vision and pattern recognition_. 1–9.
  * Takahashi et al. (2019) Akiyoshi Takahashi, Hiromitsu Shiina, and Nobuyuki Kobayashi. 2019.  Automatic Generation of Program Comments based on Problem Statements for Computational Thinking. In _2019 8th International Congress on Advanced Applied Informatics (IIAI-AAI)_. IEEE, 629–634.
  * Terada and Watanobe (2019) K. Terada and Y. Watanobe. 2019.  Code Completion for Programming Education based on Recurrent Neural Network. In _2019 IEEE 11th International Workshop on Computational Intelligence and Applications (IWCIA)_. 109–114.  https://doi.org/10.1109/IWCIA47330.2019.8955090
  * Thaller et al. (2019) H. Thaller, L. Linsbauer, and A. Egyed. 2019\.  Feature Maps: A Comprehensible Software Representation for Design Pattern Detection. In _2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER)_. 207–217.  https://doi.org/10.1109/SANER.2019.8667978
  * Thongkum and Mekruksavanich (2020) P. Thongkum and S. Mekruksavanich. 2020.  Design Flaws Prediction for Impact on Software Maintainability using Extreme Learning Machine. In _2020 Joint International Conference on Digital Arts, Media and Technology with ECTI Northern Section Conference on Electrical, Electronics, Computer and Telecommunications Engineering (ECTI DAMT NCON)_. 79–82.  https://doi.org/10.1109/ECTIDAMTNCON48261.2020.9090717
  * Tian et al. (2020) H. Tian, K. Liu, A. K. Kaboré, A. Koyuncu, L. Li, J. Klein, and T. F. Bissyandé. 2020.  Evaluating Representation Learning of Code Changes for Predicting Patch Correctness in Program Repair. In _2020 35th IEEE/ACM International Conference on Automated Software Engineering (ASE)_. 981–992.
  * Tollin et al. (2017) Irene Tollin, Francesca Arcelli Fontana, Marco Zanoni, and Riccardo Roveda. 2017.  Change Prediction through Coding Rules Violations. In _Proceedings of the 21st International Conference on Evaluation and Assessment in Software Engineering_ (Karlskrona, Sweden) _(EASE’17)_. 61–64.  https://doi.org/10.1145/3084226.3084282
  * Tsantalis et al. (2020) Nikolaos Tsantalis, Ameya Ketkar, and Danny Dig. 2020.  RefactoringMiner 2.0.  _IEEE Transactions on Software Engineering_ (2020), 21 pages.  https://doi.org/10.1109/TSE.2020.3007722
  * Tsintzira et al. (2020) Angeliki-Agathi Tsintzira, Elvira-Maria Arvanitou, Apostolos Ampatzoglou, and Alexander Chatzigeorgiou. 2020\.  Applying Machine Learning in Technical Debt Management: Future Opportunities and Challenges. In _Quality of Information and Communications Technology_ , Martin Shepperd, Fernando Brito e Abreu, Alberto Rodrigues da Silva, and Ricardo Pérez-Castillo (Eds.). 53–67.
  * Tufano et al. (2019) M. Tufano, J. Pantiuchina, C. Watson, G. Bavota, and D. Poshyvanyk. 2019.  On Learning Meaningful Code Changes Via Neural Machine Translation. In _2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE)_. 25–36.  https://doi.org/10.1109/ICSE.2019.00021
  * Tufano et al. (2018) Michele Tufano, Cody Watson, Gabriele Bavota, Massimiliano Di Penta, Martin White, and Denys Poshyvanyk. 2018.  Deep Learning Similarities from Different Representations of Source Code _(MSR ’18)_. 542–553.  https://doi.org/10.1145/3196398.3196431
  * Tufano et al. (2019a) Michele Tufano, Cody Watson, Gabriele Bavota, Massimiliano Di Penta, Martin White, and Denys Poshyvanyk. 2019a.  Learning how to mutate source code from bug-fixes. In _2019 IEEE International Conference on Software Maintenance and Evolution (ICSME)_. IEEE, 301–312.
  * Tufano et al. (2019b) Michele Tufano, Cody Watson, Gabriele Bavota, Massimiliano Di Penta, Martin White, and Denys Poshyvanyk. 2019b.  An Empirical Study on Learning Bug-Fixing Patches in the Wild via Neural Machine Translation.  _ACM Trans. Softw. Eng. Methodol._ 28, 4, Article 19 (September 2019), 29 pages.  https://doi.org/10.1145/3340544
  * Tummalapalli et al. (2022) Sahithi Tummalapalli, Lov Kumar, NL Bhanu Murthy, and Aneesh Krishna. 2022.  Detection of Web Service Anti-Patterns Using Weighted Extreme Learning Machine.  _Computer Standards & Interfaces_ (2022), 103621.
  * Tummalapalli et al. (2020a) Sahithi Tummalapalli, Lov Kumar, and N. L. Bhanu Murthy. 2020a.  Prediction of Web Service Anti-Patterns Using Aggregate Software Metrics and Machine Learning Techniques. In _Proceedings of the 13th Innovations in Software Engineering Conference on Formerly Known as India Software Engineering Conference_ (Jabalpur, India) _(ISEC 2020)_. Article 8, 11 pages.  https://doi.org/10.1145/3385032.3385042
  * Tummalapalli et al. (2021a) Sahithi Tummalapalli, Lov Kumar, Lalitha Bhanu Murthy Neti, Vipul Kocher, and Srinivas Padmanabhuni. 2021a.  A Novel Approach for the Detection of Web Service Anti-Patterns Using Word Embedding Techniques. In _International Conference on Computational Science and Its Applications_. Springer, 217–230.
  * Tummalapalli et al. (2019) Sahithi Tummalapalli, Lov Kumar, and Lalita Bhanu Murthy Neti. 2019\.  An empirical framework for web service anti-pattern prediction using machine learning techniques. In _2019 9th Annual Information Technology, Electromechanical Engineering and Microelectronics Conference (IEMECON)_. IEEE, 137–143.
  * Tummalapalli et al. (2021b) Sahithi Tummalapalli, Juhi Mittal, Lov Kumar, Lalitha Bhanu Murthy Neti, and Santanu Kumar Rath. 2021b.  An Empirical Analysis on the Prediction of Web Service Anti-patterns Using Source Code Metrics and Ensemble Techniques. In _International Conference on Computational Science and Its Applications_. Springer, 263–276.
  * Tummalapalli et al. (2020b) Sahithi Tummalapalli, NL Murthy, Aneesh Krishna, et al. 2020b.  Detection of web service anti-patterns using neural networks with multiple layers. In _International Conference on Neural Information Processing_. Springer, 571–579.
  * Ucci et al. (2019) Daniele Ucci, Leonardo Aniello, and Roberto Baldoni. 2019\.  Survey of machine learning techniques for malware analysis.  _Computers & Security_ 81 (2019), 123 – 147.  https://doi.org/10.1016/j.cose.2018.11.001
  * Uchiyama et al. (2014) S. Uchiyama, A. Kubo, H. Washizaki, and Y. Fukazawa. 2014\.  Detecting Design Patterns in Object-Oriented Program Source Code by Using Metrics and Machine Learning.  _Journal of Software Engineering and Applications_ 07 (2014), 983–998.
  * Uchôa et al. (2021) Anderson Uchôa, Caio Barbosa, Daniel Coutinho, Willian Oizumi, Wesley KG Assunçao, Silvia Regina Vergilio, Juliana Alves Pereira, Anderson Oliveira, and Alessandro Garcia. 2021.  Predicting design impactful changes in modern code review: A large-scale empirical study. In _2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR)_. IEEE, 471–482.
  * Ugurel et al. (2002) Secil Ugurel, Robert Krovetz, and C. Lee Giles. 2002\.  What’s the Code? Automatic Classification of Source Code Archives. In _Proceedings of the Eighth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining_ (Edmonton, Alberta, Canada) _(KDD ’02)_. 632–638.  https://doi.org/10.1145/775047.775141
  * Utting et al. (2020) M. Utting, B. Legeard, F. Dadeau, F. Tamagnan, and F. Bouquet. 2020.  Identifying and Generating Missing Tests using Machine Learning on Execution Traces. In _2020 IEEE International Conference On Artificial Intelligence Testing (AITest)_. 83–90.  https://doi.org/10.1109/AITEST49225.2020.00020
  * Van Thuy et al. (2018) Hoang Van Thuy, Phan Viet Anh, and Nguyen Xuan Hoai. 2018\.  Automated Large Program Repair Based on Big Code. In _Proceedings of the Ninth International Symposium on Information and Communication Technology_ (Danang City, Viet Nam) _(SoICT 2018)_. 375?–381.  https://doi.org/10.1145/3287921.3287958
  * Vasic et al. (2019) Marko Vasic, Aditya Kanade, Petros Maniatis, David Bieber, and Rishabh Singh. 2019.  Neural Program Repair by Jointly Learning to Localize and Repair.
  * Vaswani et al. (2017) Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. 2017\.  Attention is All you Need. In _Advances in Neural Information Processing Systems_ , I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (Eds.), Vol. 30. Curran Associates, Inc.  https://proceedings.neurips.cc/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf
  * Vishnu and Jevitha (2014) B. A. Vishnu and K. P. Jevitha. 2014.  Prediction of Cross-Site Scripting Attack Using Machine Learning Algorithms. In _Proceedings of the 2014 International Conference on Interdisciplinary Advances in Applied Computing_ (Amritapuri, India) _(ICONIAAC ’14)_. Association for Computing Machinery, New York, NY, USA, Article 55, 5 pages.  https://doi.org/10.1145/2660859.2660969
  * Viuginov and Filchenkov (2019) Nickolay Viuginov and Andrey Filchenkov. 2019.  A Machine Learning Based Automatic Folding of Dynamically Typed Languages. In _Proceedings of the 3rd ACM SIGSOFT International Workshop on Machine Learning Techniques for Software Quality Evaluation_ (Tallinn, Estonia) _(MaLTeSQuE 2019)_. 31–36.  https://doi.org/10.1145/3340482.3342746
  * Wan et al. (2019) Yao Wan, Jingdong Shu, Yulei Sui, Guandong Xu, Zhou Zhao, Jian Wu, and Philip S. Yu. 2019.  Multi-Modal Attention Network Learning for Semantic Source Code Retrieval. In _Proceedings of the 34th IEEE/ACM International Conference on Automated Software Engineering_ (San Diego, California) _(ASE ’19)_. 13–25.  https://doi.org/10.1109/ASE.2019.00012
  * Wan et al. (2018) Yao Wan, Zhou Zhao, Min Yang, Guandong Xu, Haochao Ying, Jian Wu, and Philip S. Yu. 2018.  Improving Automatic Source Code Summarization via Deep Reinforcement Learning. In _Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering_ (Montpellier, France) _(ASE 2018)_. 397–407.  https://doi.org/10.1145/3238147.3238206
  * Wan et al. (2019) Z. Wan, X. Xia, D. Lo, and G. C. Murphy. 2019\.  How does Machine Learning Change Software Development Practices?  _IEEE Transactions on Software Engineering_ (2019), 1–1.  https://doi.org/10.1109/TSE.2019.2937083
  * Wang et al. (2020a) Deze Wang, Wei Dong, and Shanshan Li. 2020a.  A Multi-Task Representation Learning Approach for Source Code. In _Proceedings of the 1st ACM SIGSOFT International Workshop on Representation Learning for Software Engineering and Program Languages_ (Virtual, USA) _(RL+SE &PL 2020)_. 1–2.  https://doi.org/10.1145/3416506.3423575
  * Wang et al. (2021) 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.
  * Wang et al. (2020a) R. Wang, H. Zhang, G. Lu, L. Lyu, and C. Lyu. 2020a.  Fret: Functional Reinforced Transformer With BERT for Code Summarization.  _IEEE Access_ 8 (2020), 135591–135604.  https://doi.org/10.1109/ACCESS.2020.3011744
  * Wang et al. (2019) Shuai Wang, Jinyang Liu, Ye Qiu, Zhiyi Ma, Junfei Liu, and Zhonghai Wu. 2019.  Deep Learning Based Code Completion Models for Programming Codes. In _Proceedings of the 2019 3rd International Symposium on Computer Science and Intelligent Control_ (Amsterdam, Netherlands) _(ISCSIC 2019)_. Article 16, 9 pages.  https://doi.org/10.1145/3386164.3389083
  * Wang et al. (2018) Song Wang, Taiyue Liu, Jaechang Nam, and Lin Tan. 2018\.  Deep semantic feature learning for software defect prediction.  _IEEE Transactions on Software Engineering_ 46, 12 (2018), 1267–1293.
  * Wang et al. (2016a) Song Wang, Taiyue Liu, and Lin Tan. 2016a.  Automatically Learning Semantic Features for Defect Prediction. In _Proceedings of the 38th International Conference on Software Engineering_ (Austin, Texas) _(ICSE ’16)_. 297–308.  https://doi.org/10.1145/2884781.2884804
  * Wang et al. (2019) S. Wang, M. Wen, L. Chen, X. Yi, and X. Mao. 2019.  How Different Is It Between Machine-Generated and Developer-Provided Patches? : An Empirical Study on the Correct Patches Generated by Automated Program Repair Techniques. In _2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM)_. 1–12.  https://doi.org/10.1109/ESEM.2019.8870172
  * Wang and Yao (2013) S. Wang and X. Yao. 2013.  Using Class Imbalance Learning for Software Defect Prediction.  _IEEE Transactions on Reliability_ 62, 2 (2013), 434–443.  https://doi.org/10.1109/TR.2013.2259203
  * Wang et al. (2016b) Tiejian Wang, Zhiwu Zhang, Xiaoyuan Jing, and Liqiang Zhang. 2016b.  Multiple kernel ensemble learning for software defect prediction.  _Automated Software Engineering_ 23, 4 (2016), 569–590.
  * Wang and Godfrey (2014) Wei Wang and Michael W. Godfrey. 2014.  Recommending Clones for Refactoring Using Design, Context, and History. In _2014 IEEE International Conference on Software Maintenance and Evolution_. 331–340.  https://doi.org/10.1109/ICSME.2014.55
  * Wang et al. (2020b) Wenhan Wang, Ge Li, Sijie Shen, Xin Xia, and Zhi Jin. 2020b.  Modular Tree Network for Source Code Representation Learning.  _ACM Trans. Softw. Eng. Methodol._ 29, 4, Article 31 (September 2020), 23 pages.  https://doi.org/10.1145/3409331
  * Wang et al. (2020b) W. Wang, Y. Zhang, Y. Sui, Y. Wan, Z. Zhao, J. Wu, P. Yu, and G. Xu. 2020b.  Reinforcement-Learning-Guided Source Code Summarization via Hierarchical Attention.  _IEEE Transactions on Software Engineering_ (2020), 1–1.  https://doi.org/10.1109/TSE.2020.2979701
  * Wang et al. (2020) Wenhua Wang, Yuqun Zhang, Yulei Sui, Yao Wan, Zhou Zhao, Jian Wu, Philip Yu, and Guandong Xu. 2020.  Reinforcement-learning-guided source code summarization via hierarchical attention.  _IEEE Transactions on software Engineering_ (2020).
  * Wang et al. (2020d) Xinda Wang, Shu Wang, Kun Sun, Archer Batcheller, and Sushil Jajodia. 2020d.  A Machine Learning Approach to Classify Security Patches into Vulnerability Types. In _2020 IEEE Conference on Communications and Network Security (CNS)_. 1–9.  https://doi.org/10.1109/CNS48642.2020.9162237
  * Wang et al. (2020c) Yu Wang, Ke Wang, Fengjuan Gao, and Linzhang Wang. 2020c.  Learning Semantic Program Embeddings with Graph Interval Neural Network.  _Proc. ACM Program. Lang._ 4, OOPSLA, Article 137 (November 2020), 27 pages.  https://doi.org/10.1145/3428205
  * Wei et al. (2017) Linfeng Wei, Weiqi Luo, Jian Weng, Yanjun Zhong, Xiaoqian Zhang, and Zheng Yan. 2017\.  Machine Learning-Based Malicious Application Detection of Android.  _IEEE Access_ 5 (2017), 25591–25601.  https://doi.org/10.1109/ACCESS.2017.2771470
  * White et al. (2019) Martin White, Michele Tufano, Matias Martinez, Martin Monperrus, and Denys Poshyvanyk. 2019\.  Sorting and transforming program repair ingredients via deep learning code similarities. In _2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER)_. IEEE, 479–490.
  * White et al. (2016) Martin White, Michele Tufano, Christopher Vendome, and Denys Poshyvanyk. 2016.  Deep Learning Code Fragments for Code Clone Detection. In _Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering_ (Singapore, Singapore) _(ASE 2016)_. 87–98.  https://doi.org/10.1145/2970276.2970326
  * Wu et al. (2020) Liwei Wu, Fei Li, Youhua Wu, and Tao Zheng. 2020\.  GGF: A Graph-Based Method for Programming Language Syntax Error Correction. In _Proceedings of the 28th International Conference on Program Comprehension_ _(ICPC ’20)_. Association for Computing Machinery, 139––148.  https://doi.org/10.1145/3387904.3389252
  * Xiao et al. (2020) L. Xiao, HuaiKou Miao, Tingting Shi, and Y. Hong. 2020\.  LSTM-based deep learning for spatial–temporal software testing.  _Distributed and Parallel Databases_ (2020), 1–26.
  * Xie et al. (2021) R. Xie, W. Ye, J. Sun, and S. Zhang. 2021\.  Exploiting Method Names to Improve Code Summarization: A Deliberation Multi-Task Learning Approach. In _2021 2021 IEEE/ACM 29th International Conference on Program Comprehension (ICPC) (ICPC)_. 138–148.  https://doi.org/10.1109/ICPC52881.2021.00022
  * Xiong et al. (2018) Yingfei Xiong, Bo Wang, Guirong Fu, and Linfei Zang. 2018\.  Learning to Synthesize. In _Proceedings of the 4th International Workshop on Genetic Improvement Workshop_ (Gothenburg, Sweden) _(GI ’18)_. 37–44.  https://doi.org/10.1145/3194810.3194816
  * Xu et al. (2017) Sihan Xu, Aishwarya Sivaraman, Siau-Cheng Khoo, and Jing Xu. 2017.  GEMS: An Extract Method Refactoring Recommender. In _2017 IEEE 28th International Symposium on Software Reliability Engineering (ISSRE)_. 24–34.  https://doi.org/10.1109/ISSRE.2017.35
  * Xu et al. (2019) Sihan Xu, Sen Zhang, Weijing Wang, Xinya Cao, Chenkai Guo, and Jing Xu. 2019\.  Method Name Suggestion with Hierarchical Attention Networks. In _Proceedings of the 2019 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation_ (Cascais, Portugal) _(PEPM 2019)_. 10–21.  https://doi.org/10.1145/3294032.3294079
  * Yahav (2018) Eran Yahav. 2018\.  From Programs to Interpretable Deep Models and Back. In _Computer Aided Verification_ , Hana Chockler and Georg Weissenbacher (Eds.). 27–37.
  * Yang et al. (2019b) Hangfeng Yang, Shudong Li, Xiaobo Wu, Hui Lu, and Weihong Han. 2019b.  A Novel Solutions for Malicious Code Detection and Family Clustering Based on Machine Learning.  _IEEE Access_ 7 (2019), 148853–148860.  https://doi.org/10.1109/ACCESS.2019.2946482
  * Yang et al. (2014) Jiachen Yang, K. Hotta, Yoshiki Higo, H. Igaki, and S. Kusumoto. 2014.  Classification model for code clones based on machine learning.  _Empirical Software Engineering_ 20 (2014), 1095–1125.
  * Yang et al. (2018) Mutian Yang, Jingzheng Wu, Shouling Ji, Tianyue Luo, and Yanjun Wu. 2018.  Pre-Patch: Find Hidden Threats in Open Software Based on Machine Learning Method. In _Services – SERVICES 2018_ , Alvin Yang, Siva Kantamneni, Ying Li, Awel Dico, Xiangang Chen, Rajesh Subramanyan, and Liang-Jie Zhang (Eds.). 48–65.
  * Yang et al. (2019a) Yixiao Yang, Xiang Chen, and Jiaguang Sun. 2019a.  Improve Language Modeling for Code Completion Through Learning General Token Repetition of Source Code with Optimized Memory.  _International Journal of Software Engineering and Knowledge Engineering_ 29, 11n12 (2019), 1801–1818.  https://doi.org/10.1142/S0218194019400229 arXiv:https://doi.org/10.1142/S0218194019400229
  * Yang et al. (2021) Z. Yang, J. Keung, X. Yu, X. Gu, Z. Wei, X. Ma, and M. Zhang. 2021\.  A Multi-Modal Transformer-based Code Summarization Approach for Smart Contracts. In _2021 2021 IEEE/ACM 29th International Conference on Program Comprehension (ICPC) (ICPC)_. 1–12.  https://doi.org/10.1109/ICPC52881.2021.00010
  * Yao et al. (2019) Ziyu Yao, Jayavardhan Reddy Peddamail, and Huan Sun. 2019.  CoaCor: Code Annotation for Code Retrieval with Reinforcement Learning. In _The World Wide Web Conference_ (San Francisco, CA, USA) _(WWW ’19)_. 2203–2214.  https://doi.org/10.1145/3308558.3313632
  * Yao et al. (2018) Ziyu Yao, Daniel S. Weld, Wei-Peng Chen, and Huan Sun. 2018\.  StaQC: A Systematically Mined Question-Code Dataset from Stack Overflow. In _Proceedings of the 2018 World Wide Web Conference_ (Lyon, France) _(WWW ’18)_. International World Wide Web Conferences Steering Committee, Republic and Canton of Geneva, CHE, 1693–1703.  https://doi.org/10.1145/3178876.3186081
  * Ye et al. (2020) Wei Ye, Rui Xie, Jinglei Zhang, Tianxiang Hu, Xiaoyin Wang, and Shikun Zhang. 2020\.  Leveraging Code Generation to Improve Code Retrieval and Summarization via Dual Learning. In _Proceedings of The Web Conference 2020_ (Taipei, Taiwan) _(WWW ’20)_. 2309–2319.  https://doi.org/10.1145/3366423.3380295
  * Yin et al. (2018) Pengcheng Yin, Bowen Deng, Edgar Chen, Bogdan Vasilescu, and Graham Neubig. 2018.  Learning to Mine Aligned Code and Natural Language Pairs from Stack Overflow. In _Proceedings of the 15th International Conference on Mining Software Repositories_ (Gothenburg, Sweden) _(MSR ’18)_. Association for Computing Machinery, New York, NY, USA, 476–486.  https://doi.org/10.1145/3196398.3196408
  * Yohannese and Li (2017) Chubato Wondaferaw Yohannese and Tianrui Li. 2017.  A combined-learning based framework for improved software fault prediction.  _International Journal of Computational Intelligence Systems_ 10, 1 (2017), 647.
  * Yosifova et al. (2021) Veneta Yosifova, Antoniya Tasheva, and Roumen Trifonov. 2021\.  Predicting Vulnerability Type in Common Vulnerabilities and Exposures (CVE) Database with Machine Learning Classifiers. In _2021 12th National Conference with International Participation (ELECTRONICA)_. 1–6.  https://doi.org/10.1109/ELECTRONICA52725.2021.9513723
  * Younis and Malaiya (2014) Awad A. Younis and Yashwant K. Malaiya. 2014.  Using Software Structure to Predict Vulnerability Exploitation Potential. In _2014 IEEE Eighth International Conference on Software Security and Reliability-Companion_. 13–18.  https://doi.org/10.1109/SERE-C.2014.17
  * Yue et al. (2018) R. Yue, Z. Gao, N. Meng, Y. Xiong, X. Wang, and J. D. Morgenthaler. 2018\.  Automatic Clone Recommendation for Refactoring Based on the Present and the Past. In _2018 IEEE International Conference on Software Maintenance and Evolution (ICSME)_. 115–126.  https://doi.org/10.1109/ICSME.2018.00021
  * Zanoni et al. (2015) Marco Zanoni, Francesca Arcelli Fontana, and Fabio Stella. 2015.  On applying machine learning techniques for design pattern detection.  _Journal of Systems and Software_ 103 (2015), 102–117.
  * Zhang and Tsai (2003) Du Zhang and Jeffrey J. P. Tsai. 2003.  Machine Learning and Software Engineering.  _Software Quality Journal_ 11, 2 (June 2003), 87–119.  https://doi.org/10.1023/A:1023760326768
  * Zhang and Khoo (2021) Fanlong Zhang and Siau-cheng Khoo. 2021.  An empirical study on clone consistency prediction based on machine learning.  _Information and Software Technology_ 136 (2021), 106573.
  * Zhang et al. (2020a) Jian Zhang, Xu Wang, Hongyu Zhang, Hailong Sun, and Xudong Liu. 2020a.  Retrieval-Based Neural Source Code Summarization. In _Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering_ (Seoul, South Korea) _(ICSE ’20)_. 1385–1397.  https://doi.org/10.1145/3377811.3380383
  * Zhang et al. (2019) J. Zhang, X. Wang, H. Zhang, H. Sun, K. Wang, and X. Liu. 2019.  A Novel Neural Source Code Representation Based on Abstract Syntax Tree. In _2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE)_. 783–794.  https://doi.org/10.1109/ICSE.2019.00086
  * Zhang et al. (2020b) Jinglei Zhang, Rui Xie, Wei Ye, Yuhan Zhang, and Shikun Zhang. 2020b.  Exploiting Code Knowledge Graph for Bug Localization via Bi-Directional Attention. In _Proceedings of the 28th International Conference on Program Comprehension_ _(ICPC ’20)_. Association for Computing Machinery, 219––229.  https://doi.org/10.1145/3387904.3389281
  * Zhang and Harman (2021) Jie M. Zhang and Mark Harman. 2021.  ”Ignorance and Prejudice” in Software Fairness. In _2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE)_. 1436–1447.  https://doi.org/10.1109/ICSE43902.2021.00129
  * Zhang et al. (2020) J. M. Zhang, M. Harman, L. Ma, and Y. Liu. 2020\.  Machine Learning Testing: Survey, Landscapes and Horizons.  _IEEE Transactions on Software Engineering_ (2020), 1–1.  https://doi.org/10.1109/TSE.2019.2962027
  * Zhang and Wu (2020) Q. Zhang and B. Wu. 2020.  Software Defect Prediction via Transformer. In _2020 IEEE 4th Information Technology, Networking, Electronic and Automation Control Conference (ITNEC)_ , Vol. 1. 874–879.  https://doi.org/10.1109/ITNEC48623.2020.9084745
  * Zhang and Dong (2021) Yang Zhang and Chunhao Dong. 2021.  MARS: Detecting brain class/method code smell based on metric–attention mechanism and residual network.  _Journal of Software: Evolution and Process_ (2021), e2403.
  * Zhang and Li (2020) Yu Zhang and Binglong Li. 2020.  Malicious Code Detection Based on Code Semantic Features.  _IEEE Access_ 8 (2020), 176728–176737.  https://doi.org/10.1109/ACCESS.2020.3026052
  * Zhao and Huang (2018) Gang Zhao and Jeff Huang. 2018.  DeepSim: Deep Learning Code Functional Similarity. In _Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering_ (Lake Buena Vista, FL, USA) _(ESEC/FSE 2018)_. 141–151.  https://doi.org/10.1145/3236024.3236068
  * Zheng et al. (2020) Wei Zheng, Jialiang Gao, Xiaoxue Wu, Fengyu Liu, Yuxing Xun, Guoliang Liu, and Xiang Chen. 2020.  The impact factors on the performance of machine learning-based vulnerability detection: A comparative study.  _Journal of Systems and Software_ 168 (2020), 110659.  https://doi.org/10.1016/j.jss.2020.110659
  * Zheng et al. (2019) Wenhao Zheng, Hongyu Zhou, Ming Li, and Jianxin Wu. 2019\.  CodeAttention: translating source code to comments by exploiting the code constructs.  _Frontiers of Computer Science_ 13, 3 (2019), 565–578.
  * Zhong et al. (2019) Chaoliang Zhong, Ming Yang, and Jun Sun. 2019.  JavaScript Code Suggestion Based on Deep Learning. In _Proceedings of the 2019 3rd International Conference on Innovation in Artificial Intelligence_ (Suzhou, China) _(ICIAI 2019)_. 145–149.  https://doi.org/10.1145/3319921.3319922
  * Zhou and Jiang (2012) Yajin Zhou and Xuxian Jiang. 2012.  Dissecting Android Malware: Characterization and Evolution. In _Proceedings of the 2012 IEEE Symposium on Security and Privacy_ _(SP ’12)_. 95–109.  https://doi.org/10.1109/SP.2012.16
  * Zhou et al. (2022) Yu Zhou, Juanjuan Shen, Xiaoqing Zhang, Wenhua Yang, Tingting Han, and Taolue Chen. 2022\.  Automatic source code summarization with graph attention networks.  _Journal of Systems and Software_ 188 (2022), 111257.
  * Zhou et al. (2021) Ziyi Zhou, Huiqun Yu, and Guisheng Fan. 2021.  Adversarial training and ensemble learning for automatic code summarization.  _Neural Computing and Applications_ 33, 19 (2021), 12571–12589.
  * Zhu et al. (2021) Qihao Zhu, Zeyu Sun, Yuan-an Xiao, Wenjie Zhang, Kang Yuan, Yingfei Xiong, and Lu Zhang. 2021.  A syntax-guided edit decoder for neural program repair. In _Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering_. 341–353.
  * Zimmermann et al. (2007) Thomas Zimmermann, Rahul Premraj, and Andreas Zeller. 2007\.  Predicting Defects for Eclipse. In _Third International Workshop on Predictor Models in Software Engineering (PROMISE’07: ICSE Workshops 2007)_. 9–9.  https://doi.org/10.1109/PROMISE.2007.10

##  Appendix A Abbreviations of ML techniques

Table 4. Machine learning techniques Acronym |  Full form
---|---
A3C |  Asynchronous Advantage Actor-Critic
AB |  AdaBoost
AE |  Autoencoder
AIS |  Artificial Immune Systems
ANFIS |  Adaptive Neuro-Fuzzy Inference System
ANN |  Artificial Neural Network
ARM |  Association Rule Mining
B |  Bagging
BDT |  Boosted Decision Tree
BERT |  Bidirectional Encoder Representations from Transformers
Bi-GRU |  Bidirectional Gated Recurrent Unit
Bi-LSTM |  Bi-Long Sort-Term Memory
Bi-RNN |  Bidirectional Recurrent Neural Network
BiNN |  Bilateral Neural Network
BMN |  Best Matching Neighbours
BN |  Bayes Net
BNB |  Bernoulli Naive Bayes
BOW |  Bag of Words
BP-ANN |  Back-propagation Artificial Neural Network
BR |  Binary Relevance
CART |  Classification and Regression Trees
CC |  Classifier Chain
CCN |  Cascade Correlation Network
CNN |  Convolution Neural Network
COBWEB |  COBWEB
Code2Vec |  Code2Vec
CoForest-RF |  Co-Forest Random Forest
CSC |  Cost-Sensitive Classifier
DBN |  Deep Belief Network
DDQN |  Double Deep Q-Networks
DNN |  Deep Neural Network
Doc2Vec |  Doc2Vec
DR |  Diverse Rank
DS |  Decision Stump
DT |  Decision Tree
EL |  Ensemble Learning
ELM |  Extreme Learning Machine
EM |  Expectation Minimization
EN-DE |  Encoder-Decoder
FIS |  Fuzzy Inference System
FL |  Fuzzy Logic
FR-CNN |  Faster R-Convolutional Neural Network
GAN |  Generative Adversarial Network
GB |  Gradient Boosting
GBDT |  Gradient-Boosted Decision Tree
GBM |  Gradient Boosting Machine
GBT |  Gradient boosted trees
GCN |  Graph convolutional networks
GD |  Gradient Descent
GED |  Gaussian Encoder-Decoder
GEP |  Gene Expression Programming
GGNN |  Gated Graph Neural Network
GINN |  Graph Interval Neural Network
Glove |  Global Vectors for Word Representation
GNB |  Gaussian Naïve Bayes
GNN |  Graph Neural Network
GPT-C |  Generative Pre-trained Transformer for Code
GRASSHOPER |  Graph Random-walk with Absorbing StateS that HOPs among PEaks for Ranking
GRU |  Gated Recurrent Unit
HAN |  Hierarchical Attention Network
HC |  Hierarchical Clustering
HMM |  Hidden Markov Model
KM |  KMeans
KNN |  K Nearest Neighbours
KS |  Kstar
LB |  LogitBoost
LC |  Label Combination
LCM |  Log-bilinear Context Model
LDA |  Linear Discriminant Analysis
LLR |  Logistic Linear Regression
LMSR |  Least Median Square Regression
LOG |  Logistic regression
LR |  Linear Regression
LSTM |  Long Short Term Memory
MLP |  Multi Level Perceptron
MMR |  Maximal Marginal Relevance
MNB |  Multinomial Naive Bayes
MNN |  Memory Neural Network
MTN |  Modular Tree-structured Recurrent Neural Network
MVE |  Majority Voting Ensemble
NB |  Naïve Bayes
NLM |  Neural Language Model
NMT |  Neural Machine Translation
NNC |  Neural Network for Continuous goal
NND |  Neural Network for Discrete goal
Node2Vec |  Node2Vec
OCC |  One Class Classifier
OR |  OneRule
PN |  Pointer Network
PNN |  Probabilistic Neural Network
POLY |  Polynomial regression
PR |  Pace Regression
PSO |  Particle Swarm Optimization
ReNN |  Reverse NN
ResNet |  Residual Neural Network
RF |  Random Forrest
RGNN |  Regression Neural Network
Ripper |  Ripper
RL |  Reinforcement Learning
RNN |  Recuurent Neural Network
RT |  RandomTree
SA |  Simulated Annealing
Seq2Seq |  Sequence-to-Sequence
SMO |  Sequential Minimal Optimization
SMT |  Statistical Machine Translation
SOM |  Self Organizing Map
SVE |  Soft Voting Ensemble
SVLR |  Support Vector Logistic Regression
SVM |  Support Vector Machine
SVR |  Support Vector Regression
TF |  Transformer
TNB |  Transfer Naïve Bayes
V |  Voting
VSL |  Version Space Learning
Word2Vec |  Word2Vec
XG |  XGBoost