Cited By
View all- Yu JFu MIgnatiev ATantithamthavorn CStuckey P(2024)A Formal Explainer for Just-In-Time Defect PredictionsACM Transactions on Software Engineering and Methodology10.1145/366480933:7(1-31)Online publication date: 26-Aug-2024
UniLoc: Unified Fault Localization of Continuous Integration Failures
Article No.: 136, Pages 1 - 31
Abstract
Continuous integration (CI) practices encourage developers to frequently integrate code into a shared repository. Each integration is validated by automatic build and testing such that errors are revealed as early as possible. When CI failures or integration errors are reported, existing techniques are insufficient to automatically locate the root causes for two reasons. First, a CI failure may be triggered by faults in source code and/or build scripts, whereas current approaches consider only source code. Second, a tentative integration can fail because of build failures and/or test failures, whereas existing tools focus on test failures only. This article presents UniLoc, the first unified technique to localize faults in both source code and build scripts given a CI failure log, without assuming the failure’s location (source code or build scripts) and nature (a test failure or not). Adopting the information retrieval (IR) strategy, UniLoc locates buggy files by treating source code and build scripts as documents to search and by considering build logs as search queries. However, instead of naïvely applying an off-the-shelf IR technique to these software artifacts, for more accurate fault localization, UniLoc applies various domain-specific heuristics to optimize the search queries, search space, and ranking formulas. To evaluate UniLoc, we gathered 700 CI failure fixes in 72 open source projects that are built with Gradle. UniLoc could effectively locate bugs with the average mean reciprocal rank value as 0.49, mean average precision value as 0.36, and normalized discounted cumulative gain value as 0.54. UniLoc outperformed the state-of-the-art IR-based tool BLUiR and Locus. UniLoc has the potential to help developers diagnose root causes for CI failures more accurately and efficiently.
References
[1]
Apache Ant Project. 2018. Ant. Retrieved August 18, 2018 from https://ant.apache.org/.
[2]
Apache Ant Project. 2018. Ivy. Retrieved August 18, 2018 from http://ant.apache.org/ivy/.
[3]
Apache Lucene. 2018. Lucene. Retrieved August 18, 2018 from http://lucene.apache.org/.
[4]
Apache Maven Project. 2018. Maven. Retrieved August 18, 2018 from https://maven.apache.org/.
[5]
PMD. 2018. PMD. Retrieved August 18, 2018 from https://pmd.github.io/.
[6]
Digital Ocean. 2019. An Introduction to CI/CD Best Practices. Retrieved May 16, 2023 from https://www.digitalocean.com/community/tutorials/an-introduction-to-ci-cd-best-practices.
[7]
DevOps. 2019. Why Continuous Integration Doesn’t Work. Retrieved May 16, 2023 from https://devops.com/continuous-integration-doesnt-work/.
[8]
DigitalCommons. 2022. Improving the Efficiency of CI with Uber-commits. Retrieved October 27, 2022 from https://digitalcommons.unl.edu/cgi/viewcontent.cgi?article=1126&context=computerscidiss.
[9]
GitHub. 2022. Locus Implementation. Retrieved October 27, 2022 from https://github.com/justinwm/Locus/.
[10]
R. Abreu, P. Zoeteweij, and A. J. C. Van Gemund. 2006. An evaluation of similarity coefficients for software fault localization. In Proceedings of the 2006 12th Pacific Rim International Symposium on Dependable Computing (PRDC’06). 39–46.
[11]
Rui Abreu, Peter Zoeteweij, and Arjan J. C. van Gemund. 2009. Spectrum-based multiple fault localization. In Proceedings of the 2009 IEEE/ACM International Conference on Automated Software Engineering (ASE’09). IEEE, Los Alamitos, CA, 88–99.
[12]
B. Adams, H. Tromp, K. de Schutter, and W. de Meuter. 2007. Design recovery and maintenance of build systems. In Proceedings of the 2007 IEEE International Conference on Software Maintenance. 114–123.
[13]
Jafar Al-Kofahi, Hung Viet Nguyen, and Tien N. Nguyen. 2014. Fault localization for build code errors in makefiles. In Companion Proceedings of the 36th International Conference on Software Engineering (ICSE Companion’14). ACM, New York, NY, 600–601.
[14]
Nasreddine Aoumeur and Gunter Saake. 2004. Dynamically evolving concurrent information systems specification and validation: A component-based Petri nets proposal. Data & Knowledge Engineering 50, 2 (Aug.2004), 117–173.
[15]
Nathaniel Ayewah, William Pugh, J. David Morgenthaler, John Penix, and YuQian Zhou. 2007. Using FindBugs on production software. In Companion to the 22nd ACM SIGPLAN Conference on Object-Oriented Programming Systems and Applications Companion (OOPSLA’07). ACM, New York, NY, 805–806.
[16]
Tien-Duy B. Le, David Lo, Claire Le Goues, and Lars Grunske. 2016. A learning-to-rank based fault localization approach using likely invariants. In Proceedings of the 25th International Symposium on Software Testing and Analysis (ISSTA’16). ACM, New York, NY, 177–188.
[17]
Brenda S. Baker. 1999. Parameterized diff. In Proceedings of the 10th Annual ACM-SIAM Symposium on Discrete Algorithms. 854–855.
[18]
Len Bass, Ingo Weber, and Liming Zhu. 2015. DevOps: A Software Architect’s Perspective. Addison-Wesley Professional.
[19]
M. Beller, G. Gousios, and A. Zaidman. 2017. TravisTorrent: Synthesizing Travis CI and GitHub for full-stack research on continuous integration. In Proceedings of the 2017 IEEE/ACM 14th International Conference on Mining Software Repositories. 447–450.
[20]
Tung Dao, Max Wang, and Na Meng. 2021. Exploring the triggering modes of spectrum-based fault localization: An industrial case. In Proceedings of the 2021 14th IEEE Conference on Software Testing, Verification, and Validation (ICST’21). 406–416.
[21]
Tung Dao, Lingming Zhang, and Na Meng. 2017. How does execution information help with information-retrieval based bug localization? In Proceedings of the 25th International Conference on Program Comprehension (ICPC’17). IEEE, Los Alamitos, CA, 241–250.
[22]
T. Dao, L. Zhang, and N. Meng. 2017. How does execution information help with information-retrieval based bug localization? In Proceedings of the 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC’17). 241–250.
[23]
Lisa Nguyen Quang Do, Karim Ali, Benjamin Livshits, Eric Bodden, Justin Smith, and Emerson Murphy-Hill. 2017. Just-in-time static analysis. In Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’17). ACM, New York, NY, 307–317.
[24]
Paul M. Duvall, Steve Matyas, and Andrew Glover. 2007. Continuous Integration: Improving Software Quality and Reducing Risk. Pearson Education.
[25]
Keheliya Gallaba, Christian Macho, Martin Pinzger, and Shane McIntosh. 2018. Noise and heterogeneity in historical build data: An empirical study of Travis CI. In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering (ASE’18). ACM, New York, NY, 87–97.
[26]
Taher Ghaleb, Daniel Costa, Ying Zou, and Ahmed E. Hassan. 2021. Studying the impact of noises in build breakage data. IEEE Transactions on Software Engineering 47 (2021), 1998–2011.
[27]
C. Le Goues, T. Nguyen, S. Forrest, and W. Weimer. 2012. GenProg: A generic method for automatic software repair. IEEE Transactions on Software Engineering 38, 1 (Jan.2012), 54–72.
[28]
F. Hassan, S. Mostafa, E. S. L. Lam, and X. Wang. 2017. Automatic building of Java projects in software repositories: A study on feasibility and challenges. In Proceedings of the 2017 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM’17). 38–47.
[29]
Foyzul Hassan and Xiaoyin Wang. 2017. Change-aware build prediction model for stall avoidance in continuous integration(ESEM’17). IEEE, Los Alamitos, CA, 157–162.
[30]
Foyzul Hassan and Xiaoyin Wang. 2018. HireBuild: An automatic approach to history-driven repair of build scripts. In Proceedings of the 40th International Conference on Software Engineering (ICSE’18). ACM, New York, NY, 1078–1089.
[31]
Michael Hilton, Nicholas Nelson, Timothy Tunnell, Darko Marinov, and Danny Dig. 2017. Trade-offs in continuous integration: Assurance, security, and flexibility. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering (ESEC/FSE’17). ACM, New York, NY, 197–207.
[32]
Stephen C. Johnson. 1977. Lint, a C Program Checker. Retrieved May 16, 2023 from https://wolfram.schneider.org/bsd/7thEdManVol2/lint/lint.pdf.
[33]
James A. Jones and Mary Jean Harrold. 2005. Empirical evaluation of the Tarantula automatic fault-localization technique. In Proceedings of the 20th IEEE/ACM International Conference on Automated Software Engineering (ASE’05). ACM, New York, NY, 273–282.
[34]
D. Kim, J. Nam, J. Song, and S. Kim. 2013. Automatic patch generation learned from human-written patches. In Proceedings of the 2013 35th International Conference on Software Engineering (ICSE’13). 802–811.
[35]
Sunghun Kim, Thomas Zimmermann, E. James Whitehead Jr., and Andreas Zeller. 2007. Predicting faults from cached history. In Proceedings of the 29th International Conference on Software Engineering (ICSE’07). IEEE, Los Alamitos, CA, 489–498.
[36]
Yiğit Küçük, Tim A. D. Henderson, and Andy Podgurski. 2021. Improving fault localization by integrating value and predicate based causal inference techniques. In Proceedings of the 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE’21). IEEE, Los Alamitos, CA, 649–660.
[37]
Tien-Duy B. Le, Richard J. Oentaryo, and David Lo. 2015. Information retrieval and spectrum based bug localization: Better together. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering (ESEC/FSE’15). ACM, New York, NY, 579–590.
[38]
Jaekwon Lee, Dongsun Kim, Tegawendé F. Bissyandé, Woosung Jung, and Yves Le Traon. 2018. Bench4BL: Reproducibility study on the performance of IR-based bug localization. In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’18). ACM, New York, NY, 61–72.
[39]
Jaekwon Lee, Dongsun Kim, Tegawendé F. Bissyandé, Woosung Jung, and Yves Le Traon. 2018. Bench4BL: Reproducibility study on the performance of IR-based bug localization. In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’18). ACM, New York, NY, 61–72.
[40]
Yi Li, Shaohua Wang, and Tien Nguyen. 2021. Fault localization with code coverage representation learning. In Proceedings of the 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE’21). IEEE, Los Alamitos, CA, 661–673.
[41]
Chao Liu, Xifeng Yan, Long Fei, Jiawei Han, and Samuel P. Midkiff. 2005. SOBER: Statistical model-based bug localization. In Proceedings of the 10th European Software Engineering Conference Held Jointly with the 13th ACM SIGSOFT International Symposium on Foundations of Software Engineering (ESEC/FSE’13). ACM, New York, NY, 286–295.
[42]
Fan Long and Martin Rinard. 2016. Automatic patch generation by learning correct code. In Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL’16). ACM, New York, NY, 298–312.
[43]
Yiling Lou, Qihao Zhu, Jinhao Dong, Xia Li, Zeyu Sun, Dan Hao, Lu Zhang, and Lingming Zhang. 2021. Boosting coverage-based fault localization via graph-based representation learning. In Proceedings of the 29th ACM Joint Meeting on the European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE’21). 664–676.
[44]
Lucia, Ferdian Thung, David Lo, and Lingxiao Jiang. 2012. Are faults localizable? In Proceedings of the 2012 9th IEEE Working Conference on Mining Software Repositories (MSR’12).
[45]
Christian Macho, Shane McIntosh, and Martin Pinzger. 2016. Predicting build co-changes with source code change and commit categories. In Proceedings of the International Conference on Software Analysis, Evolution, and Reengineering (SANER’16). 541–551.
[46]
C. Macho, S. McIntosh, and M. Pinzger. 2018. Automatically repairing dependency-related build breakage. In Proceedings of the 2018 IEEE 25th International Conference on Software Analysis, Evolution, and Reengineering (SANER’18). 106–117.
[47]
Shane Mcintosh, Bram Adams, and Ahmed E. Hassan. 2012. The evolution of Java build systems. Empirical Software Engineering 17, 4-5 (Aug.2012), 578–608.
[48]
Shane McIntosh, Bram Adams, Meiyappan Nagappan, and Ahmed E. Hassan. 2016. Identifying and understanding header file hotspots in C/C++ build processes. Automated Software Engineering 23, 4 (2016), 619–647.
[49]
Shane McIntosh, Meiyappan Nagappan, Bram Adams, Audris Mockus, and Ahmed E. Hassan. 2015. A large-scale empirical study of the relationship between build technology and build maintenance. Empirical Software Engineering 20, 6 (2015), 1587–1633.
[50]
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. 1169–1180.
[51]
Shaikh Mostafa, Xiaoyin Wang, and Tao Xie. 2017. PerfRanker: Prioritization of performance regression tests for collection-intensive software. In Proceedings of the 26th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA’17). ACM, New York, NY, 23–34.
[52]
Eugene W. Myers. 1986. An O(ND) difference algorithm and its variations. Algorithmica 1 (1986), 251–266.
[53]
Sangmin Park, Richard W. Vuduc, and Mary Jean Harrold. 2010. Falcon: Fault localization in concurrent programs. In Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering—Volume 1 (ICSE’10). ACM, New York, NY, 245–254.
[54]
Yuhua Qi, Xiaoguang Mao, Yan Lei, Ziying Dai, and Chengsong Wang. 2014. The strength of random search on automated program repair. In Proceedings of the 36th International Conference on Software Engineering (ICSE’14). ACM, New York, NY, 254–265.
[55]
Mohammad Masudur Rahman and Chanchal K. Roy. 2018. Improving IR-based bug localization with context-aware query reformulation. In Proceedings of the 2018 26th ACM Joint Meeting on the European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE’18). ACM, New York, NY, 621–632.
[56]
T. Rausch, W. Hummer, P. Leitner, and S. Schulte. 2017. An empirical analysis of build failures in the continuous integration workflows of Java-based open-source software. In Proceedings of the 2017 IEEE/ACM 14th International Conference on Mining Software Repositories (MSR’17). 345–355.
[57]
Zhilei Ren, He Jiang, Jifeng Xuan, and Zijiang Yang. 2018. Automated localization for unreproducible builds. In Proceedings of the 40th International Conference on Software Engineering (ICSE’18). ACM, New York, NY, 71–81.
[58]
R. K. Saha, M. Lease, S. Khurshid, and D. E. Perry. 2013. Improving bug localization using structured information retrieval. In Proceedings of the 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE’13). 345–355.
[59]
Mark Santolucito, Jialu Zhang, Ennan Zhai, Jürgen Cito, and Ruzica Piskac. 2022. Learning CI configuration correctness for early build feedback. In Proceedings of the 2022 IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER’22). 1006–1017.
[60]
Qusay Idrees Sarhan, Attila Szatmári, Rajmond Tóth, and Arpad Beszedes. 2021. CharmFL: A fault localization tool for Python. In Proceedings of the 2021 IEEE 21st International Working Conference on Source Code Analysis and Manipulation (SCAM’21). IEEE, Los Alamitos, CA, 114–119.
[61]
Tushar Sharma, Marios Fragkoulis, and Diomidis Spinellis. 2016. Does your configuration code smell? In Proceedings of the 13th International Conference on Mining Software Repositories (MSR’16). ACM, New York, NY, 189–200.
[62]
Matúš Sulír and Jaroslav Porubän. 2016. A quantitative study of Java software buildability. In Proceedings of the 7th International Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU’16). ACM, New York, NY, 17–25.
[63]
A. Tamrawi, H. A. Nguyen, H. V. Nguyen, and T. N. Nguyen. 2012. SYMake: A build code analysis and refactoring tool for makefiles. In Proceedings of the 2012 27th IEEE/ACM International Conference on Automated Software Engineering. 366–369.
[64]
C. Tantithamthavorn, R. Teekavanich, A. Ihara, and K. Matsumoto. 2013. Mining a change history to quickly identify bug locations: A case study of the Eclipse project. In Proceedings of the 2013 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW’13). 108–113.
[65]
Mohsen Vakilian, Raluca Sauciuc, J. David Morgenthaler, and Vahab Mirrokni. 2015. Automated decomposition of build targets. In Proceedings of the 37th International Conference on Software Engineering—Volume 1 (ICSE’15). IEEE, Los Alamitos, CA, 123–133. http://dl.acm.org/citation.cfm?id=2818754.2818772.
[66]
Rijnard van Tonder and Claire Le Goues. 2018. Static automated program repair for heap properties. In Proceedings of the 40th International Conference on Software Engineering (ICSE’18). ACM, New York, NY, 151–162.
[67]
Carmine Vassallo, Sebastian Proksch, Anna Jancso, Harald C. Gall, and Massimiliano Di Penta. 2020. Configuration smells in continuous delivery pipelines: A Linter and a six-month study on GitLab. In Proceedings of the28th ACM Joint Meeting on the European Software Engineering Conference and Symposium on the Foundations of Software Engineering(ESEC/FSE’20). ACM, New York, NY, 327–337.
[68]
C. Vassallo, G. Schermann, F. Zampetti, D. Romano, P. Leitner, A. Zaidman, M. Di Penta, and S. Panichella. 2017. A tale of CI build failures: An open source and a financial organization perspective. In Proceedings of the 2017 IEEE International Conference on Software Maintenance and Evolution (ICSME’17). 183–193.
[69]
Qianqian Wang, Chris Parnin, and Alessandro Orso. 2015. Evaluating the usefulness of IR-based fault localization techniques. In Proceedings of the 2015 International Symposium on Software Testing and Analysis (ISSTA’15). ACM, New York, NY, 1–11.
[70]
Shaowei Wang and David Lo. 2014. Version history, similar report, and structure: Putting them together for improved bug localization. In Proceedings of the 22nd International Conference on Program Comprehension (ICPC’14). ACM, New York, NY, 53–63.
[71]
Shaowei Wang and David Lo. 2016. AmaLgam+: Composing rich information sources for accurate bug localization: Composing rich information sources for accurate bug localization. Journal of Software: Evolution and Process 28, 10 (2016), 921–942.
[72]
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 the 40th International Conference on Software Engineering (ICSE’18). ACM, New York, NY, 1–11.
[73]
M. Wen, R. Wu, and S. Cheung. 2016. Locus: Locating bugs from software changes. In Proceedings of the 2016 31st IEEE/ACM International Conference on Automated Software Engineering (ASE’16). 262–273.
[74]
R. Wen, D. Gilbert, M. G. Roche, and S. McIntosh. 2018. BLIMP Tracer: Integrating build impact analysis with code review. In Proceedings of the 2018 IEEE International Conference on Software Maintenance and Evolution (ICSME’18). 685–694.
[75]
David Widder, Michael Hilton, Christian Kästner, and Bogdan Vasilescu. 2018. I’m leaving you, Travis: A continuous integration breakup story. In Proceedings of the International Conference on Mining Software Repositories (MSR’18). ACM, New York, NY, 165–169.
[76]
C. Wong, Y. Xiong, H. Zhang, D. Hao, L. Zhang, and H. Mei. 2014. Boosting bug-report-oriented fault localization with segmentation and stack-trace analysis. In Proceedings of the 2014 IEEE International Conference on Software Maintenance and Evolution. 181–190.
[77]
Rongxin Wu, Hongyu Zhang, Shing-Chi Cheung, and Sunghun Kim. 2014. CrashLocator: Locating crashing faults based on crash stacks. In Proceedings of the 2014 International Symposium on Software Testing and Analysis (ISSTA’14). ACM, New York, NY, 204–214.
[78]
X. Xia, D. Lo, S. McIntosh, E. Shihab, and A. E. Hassan. 2015. Cross-project build co-change prediction. In Proceedings of the 2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER’15). 311–320.
[79]
J. Xuan and M. Monperrus. 2014. Learning to combine multiple ranking metrics for fault localization. In Proceedings of the 2014 IEEE International Conference on Software Maintenance and Evolution. 191–200.
[80]
Jifeng Xuan and Martin Monperrus. 2014. Test case purification for improving fault localization. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE’14). ACM, New York, NY, 52–63.
[81]
Xin Ye, Razvan Bunescu, and Chang Liu. 2014. Learning to rank relevant files for bug reports using domain knowledge. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (FSE’14). ACM, New York, NY, 689–699.
[82]
Fiorella Zampetti, Carmine Vassallo, Sebastiano Panichella, Gerardo Canfora, Harald Gall, and Massimiliano Di Penta. 2020. An empirical characterization of bad practices in continuous integration. Empirical Software Engineering 25, 2 (2020), 1095–1135.
[83]
J. Zheng, L. Williams, N. Nagappan, W. Snipes, J. P. Hudepohl, and M. A. Vouk. 2006. On the value of static analysis for fault detection in software. IEEE Transactions on Software Engineering 32, 4 (April2006), 240–253.
[84]
J. Zhou, H. Zhang, and D. Lo. 2012. Where should the bugs be fixed? More accurate information retrieval-based bug localization based on bug reports. In Proceedings of the 2012 34th International Conference on Software Engineering (ICSE’12). 14–24.
[85]
D. Zou, J. Liang, Y. Xiong, M. D. Ernst, and L. Zhang. 2019. An empirical study of fault localization families and their combinations. IEEE Transactions on Software Engineering 47, 2 (2019), 332–347.
Index Terms
- UniLoc: Unified Fault Localization of Continuous Integration Failures
Recommendations
F3: fault localization for field failures
ISSTA 2013: Proceedings of the 2013 International Symposium on Software Testing and AnalysisReproducing and debugging field failures--failures that occur on user machines after release--are challenging tasks for developers. To help the first task, in previous work we have proposed BugRedux, a technique for reproducing, in-house, failures ...
Fault localization for build code errors in makefiles
ICSE Companion 2014: Companion Proceedings of the 36th International Conference on Software EngineeringBuilding is an important process in software development. In large software projects, build code has a high level of complexity, churn rate, and defect proneness. While several automated approaches exist to help developers in localizing faults in ...
Adding context to fault localization with integration coverage
ASE '13: Proceedings of the 28th IEEE/ACM International Conference on Automated Software EngineeringFault localization is a costly task in the debugging process. Several techniques to automate fault localization have been proposed aiming at reducing effort and time spent. Some techniques use heuristics based on code coverage data. The goal is to ...
Comments
Information & Contributors
Information
Published In
November 2023
949 pages
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 components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].
Publisher
Association for Computing Machinery
New York, NY, United States
Publication History
Published: 28 September 2023
Online AM: 08 May 2023
Accepted: 09 March 2023
Revised: 22 February 2023
Received: 06 October 2020
Published in TOSEM Volume 32, Issue 6
Check for updates
Author Tags
Qualifiers
- Research-article
Funding Sources
- National Science Foundation
Contributors
Other Metrics
Bibliometrics & Citations
Bibliometrics
Article Metrics
- View Citations1Total Citations
- 439Total Downloads
- Downloads (Last 12 months)219
- Downloads (Last 6 weeks)24
Reflects downloads up to 10 Nov 2024
Other Metrics
Citations
Cited By
View all- Yu JFu MIgnatiev ATantithamthavorn CStuckey P(2024)A Formal Explainer for Just-In-Time Defect PredictionsACM Transactions on Software Engineering and Methodology10.1145/366480933:7(1-31)Online publication date: 26-Aug-2024
View Options
Get Access
Login options
Check if you have access through your login credentials or your institution to get full access on this article.
Sign in