Detecting, Creating, Repairing, and Understanding Indivisible Multi-Hunk Bugs
Authors: 
Qi Xin, Haojun Wu, Jinran Tang, Xinyu Liu, Steven P. Reiss, Jifeng XuanAuthors Info & Claims
Article No.: 121, Pages 2747 - 2770
Abstract
This paper presents our approach proposed to detect and create indivisible multi-hunk bugs, an evaluation of existing repair techniques based on these bugs, and a study of the patches of these bugs constructed by the developers and existing tools. Multi-hunk bug repair aims to deal with complex bugs by fixing multiple locations of the program. Previous research on multi-hunk bug repair is severely misguided, as the evaluation of previous techniques is predominantly based on the Defects4J dataset containing a great deal of divisible multi-hunk bugs. A divisible multi-hunk bug is essentially a combination of multiple bugs triggering different failures and is uncommon while debugging, as the developer typically deals with one failure at a time. To address this problem and provide a better basis for multi-hunk bug repair, we propose an enumeration-based approach IBugFinder, which given a bug dataset can automatically detect divisible and indivisible bugs in the dataset and further isolate the divisible bugs into new indivisible bugs. We applied IBugFinder to 281 multi-hunk bugs from the Defects4J dataset. IBugFinder identified 139 divisible bugs and created 249 new bugs among which 105 are multi-hunk. We evaluated existing repair techniques with the indivisible multi-hunk bugs detected and created by IBugFinder and found that these techniques repaired only a small number of bugs suggesting weak multi-hunk repair abilities. We further studied the patches of indivisible multi-hunk bugs constructed by the developers and the various tools with a focus on understanding the relationships of the partial patches made at different locations. The study has led to the identification of 8 partial patch relationships, which suggest different strategies for multi-hunk patch generation and provide important implication for multi-hunk bug repair.
References
[1]
Afsoon Afzal, Manish Motwani, Kathryn T Stolee, Yuriy Brun, and Claire Le Goues. 2019. SOSRepair: Expressive semantic search for real-world program repair. IEEE Transactions on Software Engineering (TSE), 47, 10 (2019), 2162–2181. https://doi.org/10.1109/TSE.2019.2944914
[2]
2023. The AlphaRepair tool. https://zenodo.org/records/6819444
[3]
Gabin An, Juyeon Yoon, and Shin Yoo. 2021. Searching for multi-fault programs in defects4j. In International Symposium on Search Based Software Engineering (SSBSE). 153–158. https://doi.org/10.1007/978-3-030-88106-1_11
[4]
2023. The Angelix tool. http://angelix.io/
[5]
2023. The ARJA-e tool. https://github.com/yyxhdy/arja/tree/arja-e
[6]
2023. The artifact. https://github.com/qixin5/indivisible_multihunk_bug_repair
[7]
2023. The tool evaluation part of artifact. https://github.com/BaiGeiQiShi/RepairResults
[8]
Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, and Quoc Le. 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732, https://doi.org/10.48550/arXiv.2108.07732
[9]
Lili Bo, Yue Li, Xiaobing Sun, Xiaoxue Wu, and Bin Li. 2023. Vulloc: vulnerability localization based on inducing commits and fixing commits. Frontiers of Computer Science, 17, 3 (2023), 173207. https://doi.org/10.1007/s11704-022-1729-x
[10]
2023. The augmented bug dataset. https://github.com/universetraveller/CatenaD4j
[11]
2023. ChatGPT. https://chat.openai.com/
[12]
An Ran Chen, Md Nakhla Rafi, and Shaohua Wang. 2023. Back to the Future! Studying Data Cleanness in Defects4J and its Impact on Fault Localization. arXiv preprint arXiv:2310.19139, https://doi.org/10.48550/arXiv.2310.19139
[13]
Liushan Chen, Yu Pei, and Carlo A Furia. 2017. Contract-based program repair without the contracts. In Proceedings of 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE). 637–647. https://doi.org/10.1109/ASE.2017.8115674
[14]
Tian Cheng, Kunsong Zhao, Song Sun, Muhammad Mateen, and Junhao Wen. 2022. Effort-aware cross-project just-in-time defect prediction framework for mobile apps. Frontiers of Computer Science, 16, 6 (2022), 166207. https://doi.org/10.1007/s11704-021-1013-5
[15]
2023. Coming. https://github.com/SpoonLabs/coming
[16]
2023. The DEAR tool. https://github.com/AutomatedProgramRepair-2021/dear-auto-fix
[17]
2023. The DLFix tool. https://github.com/ICSE-2019-AUTOFIX/ICSE-2019-AUTOFIX
[18]
Thomas Durieux, Benjamin Danglot, Zhongxing Yu, Matias Martinez, Simon Urli, and Martin Monperrus. 2017. The Patches of the Nopol Automatic Repair System on the Bugs of Defects4J version 1.1.0. Université Lille 1 - Sciences et Technologies. https://hal.science/hal-01480084
[19]
Thomas Durieux and Martin Monperrus. 2016. IntroClassJava: A Benchmark of 297 Small and Buggy Java Programs. Universite Lille 1. https://hal.archives-ouvertes.fr/hal-01272126/document
[20]
2023. The Eclipse IDE 2023-06 R Packages. https://www.eclipse.org/downloads/packages/release/2023-06/r
[21]
Aryaz Eghbali and Michael Pradel. 2024. De-Hallucinator: Iterative Grounding for LLM-Based Code Completion. arXiv preprint arXiv:2401.01701, https://doi.org/10.48550/arXiv.2401.01701
[22]
Zhiyu Fan, Xiang Gao, Martin Mirchev, Abhik Roychoudhury, and Shin Hwei Tan. 2023. Automated repair of programs from large language models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 1469–1481. https://doi.org/10.1109/ICSE48619.2023.00128
[23]
Xiang Gao, Bo Wang, Gregory J Duck, Ruyi Ji, Yingfei Xiong, and Abhik Roychoudhury. 2021. Beyond tests: Program vulnerability repair via crash constraint extraction. ACM Transactions on Software Engineering and Methodology (TOSEM), 30, 2 (2021), 1–27. https://doi.org/10.1145/3418461
[24]
Ali Ghanbari, Samuel Benton, and Lingming Zhang. 2019. Practical program repair via bytecode mutation. In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 19–30. https://doi.org/10.1145/3293882.3330559
[25]
2023. The Git diff utility. https://git-scm.com/docs/git-diff
[26]
Claire Le Goues, Michael Pradel, and Abhik Roychoudhury. 2019. Automated program repair. Commun. ACM, 62, 12 (2019), 56–65. https://doi.org/10.1145/3318162
[27]
Sumit Gulwani, Oleksandr Polozov, and Rishabh Singh. 2017. Program synthesis. Foundations and Trends® in Programming Languages, 4, 1-2 (2017), 1–119. https://doi.org/10.1561/2500000010
[28]
2023. The GZoltar tool. https://gzoltar.com/
[29]
2024. The ITER tool. https://github.com/ASSERT-KTH/ITER
[30]
Jiajun Jiang, Yingfei Xiong, and Xin Xia. 2019. A manual inspection of defects4j bugs and its implications for automatic program repair. Science china information sciences, 62 (2019), 1–16. https://doi.org/10.1007/s11432-018-1465-6
[31]
Jiajun Jiang, Yingfei Xiong, Hongyu Zhang, Qing Gao, and Xiangqun Chen. 2018. Shaping program repair space with existing patches and similar code. In Proceedings of ACM 27th SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 298–309. https://doi.org/10.1145/3213846.3213871
[32]
Nan Jiang, Kevin Liu, Thibaud Lutellier, and Lin Tan. 2023. Impact of Code Language Models on Automated Program Repair. In Proceedings of the 45th International Conference on Software Engineering (ICSE). IEEE, 1430–1442. https://doi.org/10.1109/ICSE48619.2023.00125
[33]
Nan Jiang, Thibaud Lutellier, Yiling Lou, Lin Tan, Dan Goldwasser, and Xiangyu Zhang. 2023. Knod: Domain knowledge distilled tree decoder for automated program repair. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 1251–1263. https://doi.org/10.1109/ICSE48619.2023.00111
[34]
René Just, Darioush Jalali, and Michael D Ernst. 2014. Defects4J: A database of existing faults to enable controlled testing studies for Java programs. In Proceedings of ACM 23rd SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 437–440. https://doi.org/10.1145/2610384.2628055
[35]
Dongsun Kim, Jaechang Nam, Jaewoo Song, and Sunghun Kim. 2013. Automatic patch generation learned from human-written patches. In Proceedings of the 35th International Conference on Software Engineering (ICSE). 802–811. https://doi.org/10.1109/ICSE.2013.6606626
[36]
Jisung Kim and Byungjeong Lee. 2023. MCRepair: Multi-Chunk Program Repair via Patch Optimization with Buggy Block. In Proceedings of the 38th ACM/SIGAPP Symposium on Applied Computing (SAC). 1508–1515. https://doi.org/10.1145/3555776.3577762
[37]
Amy J Ko and Brad A Myers. 2008. Debugging reinvented: asking and answering why and why not questions about program behavior. In Proceedings of the 30th international conference on Software engineering (ICSE). 301–310. https://doi.org/10.1145/1368088.1368130
[38]
Triet HM Le, Hao Chen, and Muhammad Ali Babar. 2020. Deep learning for source code modeling and generation: Models, applications, and challenges. ACM Computing Surveys (CSUR), 53, 3 (2020), 1–38. https://doi.org/10.1145/3383458
[39]
Claire Le Goues, ThanhVu Nguyen, Stephanie Forrest, and Westley Weimer. 2011. GenProg: A generic method for automatic software repair. IEEE Transactions on Software Engineering (TSE), 38, 1 (2011), 54–72. https://doi.org/10.1109/TSE.2011.104
[40]
Yi Li, Shaohua Wang, and Tien N Nguyen. 2020. Dlfix: Context-based code transformation learning for automated program repair. In Proceedings of IEEE/ACM 42nd International Conference on Software Engineering (ICSE). 602–614. https://doi.org/10.1145/3377811.3380345
[41]
Yi Li, Shaohua Wang, and Tien N Nguyen. 2022. DEAR: A novel deep learning-based approach for automated program repair. In Proceedings of IEEE/ACM 44th International Conference on Software Engineering (ICSE). 25–27. https://doi.org/10.1145/3510003.3510177
[42]
Kui Liu, Anil Koyuncu, Dongsun Kim, and Tegawendé F Bissyandé. 2019. TBar: Revisiting template-based automated program repair. In Proceedings of ACM 28th SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 31–42. https://doi.org/10.1145/3293882.3330577
[43]
Fernanda Madeiral, Simon Urli, Marcelo Maia, and Martin Monperrus. 2019. Bears: An extensible java bug benchmark for automatic program repair studies. In 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER). 468–478. https://doi.org/10.1109/SANER.2019.8667991
[44]
Matias Martinez, Thomas Durieux, Romain Sommerard, Jifeng Xuan, and Martin Monperrus. 2017. Automatic repair of real bugs in java: A large-scale experiment on the defects4j dataset. Empirical Software Engineering, 22 (2017), 1936–1964. https://doi.org/10.1007/s10664-016-9470-4
[45]
2023. The artifact of MCRepair. https://github.com/kimjisung78/MCRepair
[46]
Sergey Mechtaev, Jooyong Yi, and Abhik Roychoudhury. 2016. Angelix: Scalable multiline program patch synthesis via symbolic analysis. In Proceedings of IEEE/ACM 38th International Conference on Software Engineering (ICSE). 691–701. https://doi.org/10.1145/2884781.2884807
[47]
Xiangxin Meng, Xu Wang, Hongyu Zhang, Hailong Sun, and Xudong Liu. 2022. Improving fault localization and program repair with deep semantic features and transferred knowledge. In Proceedings of the 44th International Conference on Software Engineering (ICSE). 1169–1180. https://doi.org/10.1145/3510003.3510147
[48]
Xiangxin Meng, Xu Wang, Hongyu Zhang, Hailong Sun, Xudong Liu, and Chunming Hu. 2023. Template-based Neural Program Repair. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 1456–1468. https://doi.org/10.1109/ICSE48619.2023.00127
[49]
Martin Monperrus. 2018. The Living review on automated program repair. HAL/archives-ouvertes.fr.
[50]
2023. ODS. https://github.com/SophieHYe/ODSExperiment
[51]
Alexandre Perez, Rui Abreu, and Marcelo d’Amorim. 2017. Prevalence of single-fault fixes and its impact on fault localization. In 2017 IEEE International Conference on Software Testing, Verification and Validation (ICST). 12–22. https://doi.org/10.1109/ICST.2017.9
[52]
Julian Aron Prenner, Hlib Babii, and Romain Robbes. 2022. Can OpenAI’s codex fix bugs? an evaluation on QuixBugs. In Proceedings of the Third International Workshop on Automated Program Repair (APR). 69–75. https://doi.org/10.1145/3524459.3527351
[53]
2023. The Recoder tool. https://github.com/pkuzqh/Recoder
[54]
2023. The RewardRepair tool. https://github.com/ASSERT-KTH/RewardRepair
[55]
Ripon K Saha, Yingjun Lyu, Wing Lam, Hiroaki Yoshida, and Mukul R Prasad. 2018. Bugs.jar: A large-scale, diverse dataset of real-world java bugs. In Proceedings of the 15th international conference on mining software repositories (MSR). 10–13. https://doi.org/10.1145/3196398.3196473
[56]
Ripon K Saha, Yingjun Lyu, Hiroaki Yoshida, and Mukul 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
[57]
Seemanta Saha, Ripon k. Saha, and Mukul r. Prasad. 2019. Harnessing evolution for multi-hunk program repair. In Proceedings of IEEE/ACM 41st International Conference on Software Engineering (ICSE). 13–24. https://doi.org/10.1109/ICSE.2019.00020
[58]
2023. The SimFix tool. https://github.com/xgdsmileboy/SimFix
[59]
Dominik Sobania, Martin Briesch, Carol Hanna, and Justyna Petke. 2023. An analysis of the automatic bug fixing performance of chatgpt. arXiv preprint arXiv:2301.08653, https://doi.org/10.48550/arXiv.2301.08653
[60]
Victor Sobreira, Thomas Durieux, Fernanda Madeiral, Martin Monperrus, and Marcelo de Almeida Maia. 2018. Dissection of a bug dataset: Anatomy of 395 patches from defects4j. In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER). 130–140. https://doi.org/10.1109/SANER.2018.8330203
[61]
Yi Song, Xiaoyuan Xie, Quanming Liu, Xihao Zhang, and Xi Wu. 2022. A comprehensive empirical investigation on failure clustering in parallel debugging. Journal of Systems and Software, 193 (2022), 111452. https://doi.org/10.1016/j.jss.2022.111452
[62]
2023. The Soot framework. http://soot-oss.github.io/soot/
[63]
Shin Hwei Tan, Hiroaki Yoshida, Mukul R Prasad, and Abhik Roychoudhury. 2016. Anti-patterns in search-based program repair. In Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE). 727–738. https://doi.org/10.1145/2950290.2950295
[64]
2023. The TBar tool. https://github.com/TruX-DTF/TBar
[65]
Nikolaos Tsantalis, Ameya Ketkar, and Danny Dig. 2020. RefactoringMiner 2.0. IEEE Transactions on Software Engineering (TSE), 48, 3 (2020), 930–950. https://doi.org/10.1109/TSE.2020.3007722
[66]
2023. The VarFix tool. https://github.com/chupanw/vbc
[67]
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 (ICSE). 297–308. https://doi.org/10.1145/2884781.2884804
[68]
Yuxiang Wei, Chunqiu Steven Xia, and Lingming Zhang. 2023. Copiloting the copilots: Fusing large language models with completion engines for automated program repair. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). 172–184. https://doi.org/10.1145/3611643.3616271
[69]
Ming Wen, Junjie Chen, Rongxin Wu, Dan Hao, and Shing-Chi Cheung. 2018. Context-aware patch generation for better automated program repair. In Proceedings of IEEE/ACM 40th International Conference on Software Engineering (ICSE). 1–11. https://doi.org/10.1145/3180155.3180233
[70]
Chu-Pan Wong, Priscila Santiesteban, Christian Kästner, and Claire Le Goues. 2021. VarFix: Balancing edit expressiveness and search effectiveness in automated program repair. In Proceedings of ACM 29th Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). 354–366. https://doi.org/10.1145/3468264.3468600
[71]
Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. 2023. Automated program repair in the era of large pre-trained language models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 1482–1494. https://doi.org/10.1109/ICSE48619.2023.00129
[72]
Chunqiu Steven Xia and Lingming Zhang. 2022. Less training, more repairing please: revisiting automated program repair via zero-shot learning. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). 959–971. https://doi.org/10.1145/3540250.3549101
[73]
Chunqiu Steven Xia and Lingming Zhang. 2023. Keep the Conversation Going: Fixing 162 out of 337 bugs for $0.42 each using ChatGPT. arXiv preprint arXiv:2304.00385, https://doi.org/10.48550/arXiv.2304.00385
[74]
Qi Xin and Steven P Reiss. 2017. Leveraging syntax-related code for automated program repair. In Proceedings of IEEE/ACM 32nd International Conference on Automated Software Engineering (ASE). 660–670. https://doi.org/10.1109/ASE.2017.8115676
[75]
Qi Xin, Haojun Wu, Jinran Tang, Xinyu Liu, Steven P. Reiss, and Jifeng Xuan. 2024. Detecting, Creating, Repairing, and Understanding Indivisible Multi-Hunk Bugs: Replication Package. https://doi.org/10.5281/zenodo.11097846
[76]
Yingfei Xiong, Jie Wang, Runfa Yan, Jiachen Zhang, Shi Han, Gang Huang, and Lu Zhang. 2017. Precise condition synthesis for program repair. In Proceedings of IEEE/ACM 39th International Conference on Software Engineering (ICSE). 416–426. https://doi.org/10.1109/ICSE.2017.45
[77]
Jifeng Xuan, Matias Martinez, Favio Demarco, Maxime Clement, Sebastian Lamelas Marcote, Thomas Durieux, Daniel Le Berre, and Martin Monperrus. 2016. Nopol: Automatic repair of conditional statement bugs in java programs. IEEE Transactions on Software Engineering (TSE), 43, 1 (2016), 34–55. https://doi.org/10.1109/TSE.2016.2560811
[78]
Deheng Yang, Xiaoguang Mao, Liqian Chen, Xuezheng Xu, Yan Lei, David Lo, and Jiayu He. 2022. TransplantFix: Graph Differencing-based Code Transplantation for Automated Program Repair. In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering (ASE). 1–13. https://doi.org/10.1145/3551349.3556893
[79]
He Ye, Matias Martinez, and Martin Monperrus. 2022. Neural program repair with execution-based backpropagation. In Proceedings of the 44th International Conference on Software Engineering (ICSE). 1506–1518. https://doi.org/10.1145/3510003.3510222
[80]
He Ye and Martin Monperrus. 2024. ITER: Iterative Neural Repair for Multi-Location Patches. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering (ICSE). 1–13. https://doi.org/10.1145/3597503.3623337
[81]
Jooyong Yi, Umair Z Ahmed, Amey Karkare, Shin Hwei Tan, and Abhik Roychoudhury. 2017. A feasibility study of using automated program repair for introductory programming assignments. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (FSE). 740–751. https://doi.org/10.1145/3106237.3106262
[82]
Shin Yoo and Mark Harman. 2012. Regression testing minimization, selection and prioritization: a survey. Software testing, verification and reliability, 22, 2 (2012), 67–120. https://doi.org/10.1002/stv.430
[83]
Yuan Yuan and Wolfgang Banzhaf. 2018. ARJA: Automated repair of java programs via multi-objective genetic programming. IEEE Transactions on software engineering (TSE), 46, 10 (2018), 1040–1067. https://doi.org/10.1109/TSE.2018.2874648
[84]
Yuan Yuan and Wolfgang Banzhaf. 2019. A hybrid evolutionary system for automatic software repair. In Proceedings of the Genetic and Evolutionary Computation Conference (GECCO). 1417–1425. https://doi.org/10.1145/3321707.3321830
[85]
Yuan Yuan and Wolfgang Banzhaf. 2020. Toward better evolutionary program repair: An integrated approach. ACM Transactions on Software Engineering and Methodology (TOSEM), 29, 1 (2020), 1–53. https://doi.org/10.1145/3360004
[86]
Abubakar Zakari and Sai Peck Lee. 2019. Parallel debugging: An investigative study. Journal of Software: Evolution and Process, 31, 11 (2019), e2178. https://doi.org/10.1002/smr.2178
[87]
Abubakar Zakari, Sai Peck Lee, Rui Abreu, Babiker Hussien Ahmed, and Rasheed Abubakar Rasheed. 2020. Multiple fault localization of software programs: A systematic literature review. Information and Software Technology, 124 (2020), 106312. https://doi.org/10.1016/j.infsof.2020.106312
[88]
Quanjun Zhang, Chunrong Fang, Yuxiang Ma, Weisong Sun, and Zhenyu Chen. 2023. A survey of learning-based automated program repair. ACM Transactions on Software Engineering and Methodology (TOSEM), 33, 2 (2023), 1–69. https://doi.org/10.1145/3631974
[89]
Hao Zhong and Zhendong Su. 2015. An empirical study on real bug fixes. In Proceedings of IEEE/ACM 37th International Conference on Software Engineering (ICSE). 1, 913–923. https://doi.org/10.1109/ICSE.2015.101
[90]
Wenkang Zhong, Chuanyi Li, Kui Liu, Tongtong Xu, Jidong Ge, Tegawendé F Bissyandé, Bin Luo, and Vincent Ng. 2024. Practical Program Repair via Preference-based Ensemble Strategy. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering (ICSE). 1–13. https://doi.org/10.1145/3597503.3623310
[91]
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 ACM 29th Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). 341–353. https://doi.org/10.1145/3468264.3468544
Index Terms
- Detecting, Creating, Repairing, and Understanding Indivisible Multi-Hunk Bugs
Recommendations
Where were the repair ingredients for Defects4j bugs?: Exploring the impact of repair ingredient retrieval on the performance of 24 program repair systems
AbstractA significant body of automated program repair research has built approaches under the redundancy assumption. Patches are then heuristically generated by leveraging repair ingredients (change actions and donor code) that are found in code bases (...
Understanding and Detecting Harmful Code
SBES '20: Proceedings of the XXXIV Brazilian Symposium on Software EngineeringCode smells typically indicate poor design implementation and choices that may degrade software quality. Hence, they need to be carefully detected to avoid such poor design. In this context, some studies try to understand the impact of code smells on the ...
Detecting and repairing performance bugs using execution and code patterns (invited talk abstract)
WODA+PERTEA 2014: Proceedings of the 2014 Joint International Workshop on Dynamic Analysis (WODA) and Software and System Performance Testing, Debugging, and Analytics (PERTEA)Software performance is critical for the overall success of a software project. Performance bugs are programming mistakes that slow down program execution. Performance bugs create poor user experience and affect the user-perceived software quality. ...
Comments
Please enable JavaScript to view thecomments powered by Disqus.Information & Contributors
Information
Published In
July 2024
2770 pages
Copyright © 2024 Copyright held by the owner/author(s).
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for third-party components of this work must be honored. For all other uses, contact the owner/author(s).
Publisher
Association for Computing Machinery
New York, NY, United States
Publication History
Published: 12 July 2024
Published in PACMSE Volume 1, Issue FSE
Badges
Author Tags
Qualifiers
- Research-article
Funding Sources
- National Natural Science Foundation of China
Contributors
Other Metrics
Bibliometrics & Citations
Bibliometrics
Article Metrics
- 0Total Citations
- 484Total Downloads
- Downloads (Last 12 months)484
- Downloads (Last 6 weeks)72
Reflects downloads up to 20 Jan 2025
Other Metrics
Citations
View Options
Login options
Check if you have access through your login credentials or your institution to get full access on this article.
Sign in