research-article

Which builds are really safe to skip? Maximizing failure observation for build selection in continuous integration

Authors:

Francisco ServantAuthors Info & Claims

Volume 188, Issue C

https://doi.org/10.1016/j.jss.2022.111292

Published: 01 June 2022 Publication History

Abstract

Continuous integration (CI) is a widely used practice in modern software engineering. Unfortunately, it is also an expensive practice. Google and Mozilla estimate their expenses for their CI systems in millions of dollars. To reduce the cost of CI, researchers developed multiple approaches to reduce its computational workload requirements. However, these approaches sometimes make mispredictions and skip failing builds which are not desirable to be skipped. Thus, in this paper, we aim to save computational cost in CI, while also maximizing the observation of failing builds, i.e., to skip builds more safely. First, we perform empirical studies to understand which builds are safe to skip, starting from CI-Skip rules (Abdalkareem et al., 2019) that characterize builds that developers decide to skip. We observe that CI-Skip rules are not so safe as expected. We then develop a collection of CI-Run rules that can complement these rules. Based on our findings, we propose PreciseBuildSkip, a novel approach that maximizes build failure observation and reduces the cost of CI through the strategy of build selection. We evaluate our approach and results show that our approach saved more cost (5.5%) than the safest existing technique but reduced the falsely skipped failing builds from 4.1% to 0% (median value).

Highlights

•

The summary of 8 CI-Skip rules.

•

The analysis of CI-Skip rules safety and cost-saving ability.

•

The summary of 4 CI-Run rules.

•

The study of the correlations between CI-Run rules and CI-Skip rules.

•

PreciseBuildSkip, a safe build selection approach, and its evaluation.

References

[1]

Abdalkareem R., Mujahid S., Shihab E., A machine learning approach to improve the detection of CI skip commits, IEEE Transactions on Software Engineering (TSE) (2020).

[2]

Abdalkareem R., Mujahid S., Shihab E., Rilling J., Which commits can be CI skipped?, IEEE Trans. Softw. Eng. (2019).

[3]

Beller M., Gousios G., Zaidman A., Oops, my tests broke the build: An explorative analysis of travis CI with GitHub, in: 2017 IEEE/ACM 14th International Conference on Mining Software Repositories, MSR, IEEE, 2017, pp. 356–367.

[4]

Beller M., Gousios G., Zaidman A., Travistorrent: Synthesizing travis ci and github for full-stack research on continuous integration, in: Mining Software Repositories (MSR), 2017 IEEE/ACM 14th International Conference on, IEEE, 2017, pp. 447–450.

[5]

Cataldo M., Herbsleb J.D., Factors leading to integration failures in global feature-oriented development: an empirical analysis, in: Proceedings of the 33rd International Conference on Software Engineering, ACM, 2011, pp. 161–170.

[6]

Celik A., Knaust A., Milicevic A., Gligoric M., Build system with lazy retrieval for java projects, in: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering, ACM, 2016, pp. 643–654.

[7]

Cochran W.G., Sampling techniques-3, Wiley, New York, NY (USA), 1977.

[8]

Duvall P.M., Matyas S., Glover A., Continuous Integration: Improving Software Quality and Reducing Risk, Pearson Education, 2007.

[9]

Elbaum S., Malishevsky A.G., Rothermel G., Test case prioritization: A family of empirical studies, IEEE Trans. Softw. Eng. 28 (2) (2002) 159–182.

Digital Library

[10]

Elbaum, S., Rothermel, G., Penix, J., 2014. Techniques for improving regression testing in continuous integration development environments. In: Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. pp. 235–245.

[11]

Elsaid E., Rubrowser (ruby browser), 2019, Online https://github.com/emad-elsaid/rubrowser. (Accessed 21 January 2022).

[12]

Felidré, W., Furtado, L., Da Costa, D.A., Cartaxo, B., Pinto, G., 2019. Continuous Integration Theater. In: Proceedings of the 13th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement. p. 10.

[13]

Fowler M., Foemmel M., Continuous integration, Thought-Works 122 (2006) 14. http://www. thoughtworks. com/continuous integration. pdf.

[14]

Gallaba K., Macho C., Pinzger M., McIntosh S., 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, ACM, 2018, pp. 87–97.

[15]

Gambi A., Rostyslav Z., Dustdar S., Improving cloud-based continuous integration environments, in: Proceedings of the 37th International Conference on Software Engineering-Volume 2, IEEE Press, 2015, pp. 797–798.

[16]

Gautam A., Vishwasrao S., Servant F., An empirical study of activity, popularity, size, testing, and stability in continuous integration, in: 2017 IEEE/ACM 14th International Conference on Mining Software Repositories, MSR, IEEE, 2017, pp. 495–498.

[17]

Ghaleb T.A., da Costa D.A., Zou Y., An empirical study of the long duration of continuous integration builds, Empir. Softw. Eng. (2019) 1–38.

[18]

Gligoric, M., Eloussi, L., Marinov, D., 2015. Practical regression test selection with dynamic file dependencies. In: Proceedings of the 2015 International Symposium on Software Testing and Analysis. pp. 211–222.

[19]

Hassan F., Mostafa S., Lam E.S., Wang X., Automatic building of java projects in software repositories: A study on feasibility and challenges, in: 2017 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, ESEM, IEEE, 2017, pp. 38–47.

[20]

Hassan F., Wang X., Change-aware build prediction model for stall avoidance in continuous integration, in: 2017 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, ESEM, IEEE, 2017, pp. 157–162.

[21]

Hassan F., Wang X., HireBuild: An automatic approach to history-driven repair of build scripts, in: 2018 IEEE/ACM 40th International Conference on Software Engineering, ICSE, IEEE, 2018, pp. 1078–1089.

[22]

Herzig K., Greiler M., Czerwonka J., Murphy B., The art of testing less without sacrificing quality, in: 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering, 1, IEEE, 2015, pp. 483–493.

[23]

Herzig K., Zeller A., The impact of tangled code changes, in: 2013 10th Working Conference on Mining Software Repositories, MSR, IEEE, 2013, pp. 121–130.

[24]

Hilton M., Nelson N., Tunnell T., Marinov D., Dig D., Trade-offs in continuous integration: assurance, security, and flexibility, in: Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering, ACM, 2017, pp. 197–207.

[25]

Hilton M., Tunnell T., Huang K., Marinov D., Dig D., Usage, costs, and benefits of continuous integration in open-source projects, in: Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, ACM, 2016, pp. 426–437.

[26]

Islam M.R., Zibran M.F., Insights into continuous integration build failures, in: 2017 IEEE/ACM 14th International Conference on Mining Software Repositories, MSR, IEEE, 2017, pp. 467–470.

[27]

Jain R., Singh S.K., Mishra B., A brief study on build failures in continuous integration: Causation and effect, in: Progress in Advanced Computing and Intelligent Engineering, Springer, 2019, pp. 17–27.

[28]

Jin X., Minimizing the Side Effect of Cost-saving Build Selection in Continuous Integration, Zenodo, 2020,.

[29]

Jin, X., Servant, F., 2018. The hidden cost of code completion: Understanding the impact of the recommendation-list length on its efficiency. In: Proceedings of the 15th International Conference on Mining Software Repositories. pp. 70–73.

[30]

Jin, X., Servant, F., 2020. A Cost-efficient Approach to Building in Continuous Integration. In: Proceedings of the 42th International Conference on Software Engineering. pp. 13–25.

[31]

Jin X., Servant F., What helped, and what did not? An evaluation of the strategies to improve continuous integration, in: 2021 IEEE/ACM 43rd International Conference on Software Engineering, ICSE, IEEE, 2021, pp. 213–225.

[32]

Jin X., Servant F., CIBench: a dataset and collection of techniques for build and test selection and prioritization in continuous integration, in: 2021 IEEE/ACM 43rd International Conference on Software Engineering: Companion Proceedings (ICSE-Companion), IEEE, 2021, pp. 166–167.

[33]

John O’Duinn X., The financial cost of a checkin, 2013, Online URL https://https://oduinn.com/2013/12/13/the-financial-cost-of-a-checkin-part-2/. (Accessed 25 January 2019).

[34]

Kazerouni A.M., Davis J.C., Basak A., Shaffer C.A., Servant F., Edwards S.H., Fast and accurate incremental feedback for students’ software tests using selective mutation analysis, J. Syst. Softw. 175 (2021).

[35]

Kazerouni, A.M., Shaffer, C.A., Edwards, S.H., Servant, F., 2019. Assessing incremental testing practices and their impact on project outcomes. In: Proceedings of the 50th ACM Technical Symposium on Computer Science Education. pp. 407–413.

[36]

Kerzazi N., Khomh F., Adams B., Why do automated builds break? an empirical study, in: 2014 IEEE International Conference on Software Maintenance and Evolution, ICSME, IEEE, 2014, pp. 41–50.

[37]

Leppänen M., Mäkinen S., Pagels M., Eloranta V.-P., Itkonen J., Mäntylä M.V., Männistö T., The highways and country roads to continuous deployment, Ieee Softw. 32 (2) (2015) 64–72.

Digital Library

[38]

Liang J., Cost-EFFECTIVE techniques FOR continuoUS integration TESTING, 2018.

[39]

Liang, J., Elbaum, S., Rothermel, G., 2018. Redefining prioritization: continuous prioritization for continuous integration. In: Proceedings of the 40th International Conference on Software Engineering. pp. 688–698.

[40]

Luo Q., Moran K., Poshyvanyk D., Di Penta M., Assessing test case prioritization on real faults and mutants, in: 2018 IEEE International Conference on Software Maintenance and Evolution, ICSME, IEEE, 2018, pp. 240–251.

[41]

Machalica M., Samylkin A., Porth M., Chandra S., Predictive test selection, in: 2019 IEEE/ACM 41st International Conference on Software Engineering: Software Engineering in Practice, ICSE-SEIP, IEEE, 2019, pp. 91–100.

[42]

Marijan D., Gotlieb A., Sen S., Test case prioritization for continuous regression testing: An industrial case study, in: 2013 IEEE International Conference on Software Maintenance, IEEE, 2013, pp. 540–543.

[43]

Memon A., Gao Z., Nguyen B., Dhanda S., Nickell E., Siemborski R., Micco J., Taming google-scale continuous testing, in: 2017 IEEE/ACM 39th International Conference on Software Engineering: Software Engineering in Practice Track, ICSE-SEIP, IEEE, 2017, pp. 233–242.

[44]

Micco J., The state of continuous integration testing at google, 2017.

[45]

Miller A., A hundred days of continuous integration, in: Agile 2008 Conference, IEEE, 2008, pp. 289–293.

[46]

Mostafa, S., Wang, X., Xie, T., 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. pp. 23–34.

[47]

Ni A., Li M., Cost-effective build outcome prediction using cascaded classifiers, in: 2017 IEEE/ACM 14th International Conference on Mining Software Repositories, MSR, IEEE, 2017, pp. 455–458.

[48]

Paixão K.V., Felício C.Z., Delfim F.M., de A Maia M., On the interplay between non-functional requirements and builds on continuous integration, in: Proceedings of the 14th International Conference on Mining Software Repositories, IEEE Press, 2017, pp. 479–482.

[49]

Pinto G., Rebouças M., Castor F., Inadequate testing, time pressure, and (over) confidence: a tale of continuous integration users, in: Proceedings of the 10th International Workshop on Cooperative and Human Aspects of Software Engineering, IEEE Press, 2017, pp. 74–77.

[50]

Rausch T., Hummer W., Leitner P., Schulte S., An empirical analysis of build failures in the continuous integration workflows of java-based open-source software, in: Proceedings of the 14th International Conference on Mining Software Repositories, IEEE Press, 2017, pp. 345–355.

[51]

Rebouças M., Santos R.O., Pinto G., Castor F., How does contributors’ involvement influence the build status of an open-source software project?, in: Proceedings of the 14th International Conference on Mining Software Repositories, IEEE Press, 2017, pp. 475–478.

[52]

Rothermel G., Harrold M.J., Analyzing regression test selection techniques, IEEE Trans. Softw. Eng. 22 (8) (1996) 529–551.

Digital Library

[53]

Rothermel G., Harrold M.J., A safe, efficient regression test selection technique, ACM Trans. Softw. Eng. Methodol. (TOSEM) 6 (2) (1997) 173–210.

[54]

Rothermel G., Untch R.H., Chu C., Harrold M.J., Prioritizing test cases for regression testing, IEEE Trans. Softw. Eng. 27 (10) (2001) 929–948.

Digital Library

[55]

Safwan, K.A., Servant, F., 2019. Decomposing the rationale of code commits: the software developer’s perspective. In: Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. pp. 397–408.

[56]

Schein, A.I., Popescul, A., Ungar, L.H., Pennock, D.M., 2002. Methods and metrics for cold-start recommendations. In: Proceedings of the 25th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval. pp. 253–260.

[57]

SciTools Understand A.I., Understand static code analysis tool, 2020, Online https://scitools.com/. (Accessed 02 March 2020).

[58]

Seo H., Sadowski C., Elbaum S., Aftandilian E., Bowdidge R., Programmers’ build errors: a case study (at google), in: Proceedings of the 36th International Conference on Software Engineering, ACM, 2014, pp. 724–734.

[59]

Servant F., Supporting bug investigation using history analysis, in: 2013 28th IEEE/ACM International Conference on Automated Software Engineering, ASE, IEEE, 2013, pp. 754–757.

[60]

Servant F., Jones J.A., History slicing, in: 2011 26th IEEE/ACM International Conference on Automated Software Engineering, ASE 2011, IEEE, 2011, pp. 452–455.

[61]

Servant, F., Jones, J.A., 2012. History slicing: assisting code-evolution tasks. In: Proceedings of the ACM SIGSOFT 20th International Symposium on the Foundations of Software Engineering. pp. 1–11.

[62]

Servant F., Jones J.A., Chronos: Visualizing slices of source-code history, in: 2013 First IEEE Working Conference on Software Visualization, VISSOFT, IEEE, 2013, pp. 1–4.

[63]

Servant F., Jones J.A., Fuzzy fine-grained code-history analysis, in: 2017 IEEE/ACM 39th International Conference on Software Engineering, ICSE, IEEE, 2017, pp. 746–757.

[64]

Shi A., Thummalapenta S., Lahiri S.K., Bjorner N., Czerwonka J., Optimizing test placement for module-level regression testing, in: 2017 IEEE/ACM 39th International Conference on Software Engineering, ICSE, IEEE, 2017, pp. 689–699.

[65]

Ståhl, D., Bosch, J., 2013. Experienced benefits of continuous integration in industry software product development: A case study. In: The 12th Iasted International Conference on Software Engineering. (Innsbruck, Austria, 2013), pp. 736–743.

[66]

Tufano, M., Sajnani, H., Herzig, K., 2019. Towards Predicting the Impact of Software Changes on Building Activities. In: 2019 IEEE/ACM 41st International Conference on Software Engineering: New Ideas and Emerging Results. ICSE-NIER, In: ICSE ’19.

[67]

Vasilescu B., Van Schuylenburg S., Wulms J., Serebrenik A., van den Brand M.G., Continuous integration in a social-coding world: Empirical evidence from GitHub, in: 2014 IEEE International Conference on Software Maintenance and Evolution, IEEE, 2014, pp. 401–405.

[68]

Vasilescu B., Yu Y., Wang H., Devanbu P., Filkov V., Quality and productivity outcomes relating to continuous integration in GitHub, in: Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering, ACM, 2015, pp. 805–816.

[69]

Vassallo C., Schermann G., Zampetti F., Romano D., Leitner P., Zaidman A., Di Penta M., Panichella S., A tale of CI build failures: An open source and a financial organization perspective, in: 2017 IEEE International Conference on Software Maintenance and Evolution, ICSME, IEEE, 2017, pp. 183–193.

[70]

Widder D.G., Hilton M., Kästner C., Vasilescu B., A conceptual replication of continuous integration pain points in the context of travis CI, in: Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, ACM, 2019, pp. 647–658.

[71]

Wikipedia contributors D.G., Cold start (computing) — Wikipedia, the free encyclopedia, 2019, Online URL https://en.wikipedia.org/w/index.php?title=Cold_start_(computing)&oldid=883021431. (Accessed 21 February 2019).

[72]

Yoo S., Harman M., Pareto efficient multi-objective test case selection, in: Proceedings of the 2007 International Symposium on Software Testing and Analysis, ACM, 2007, pp. 140–150.

[73]

Yoo S., Harman M., Regression testing minimization, selection and prioritization: a survey, Softw. Test. Verif. Reliab. 22 (2) (2012) 67–120.

Digital Library

[74]

Zampetti F., Scalabrino S., Oliveto R., Canfora G., Di Penta M., How open source projects use static code analysis tools in continuous integration pipelines, in: 2017 IEEE/ACM 14th International Conference on Mining Software Repositories, MSR, IEEE, 2017, pp. 334–344.

[75]

Zhang L., Hybrid regression test selection, in: 2018 IEEE/ACM 40th International Conference on Software Engineering, ICSE, IEEE, 2018, pp. 199–209.

[76]

Zhang, C., Chen, B., Chen, L., Peng, X., Zhao, W., 2019. A Large-Scale Empirical Study of Compiler Errors in Continuous Integration. In: Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering.

[77]

Zhao Y., Serebrenik A., Zhou Y., Filkov V., Vasilescu B., The impact of continuous integration on other software development practices: a large-scale empirical study, in: Proceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering, IEEE Press, 2017, pp. 60–71.

[78]

Zhu C., Legunsen O., Shi A., Gligoric M., A framework for checking regression test selection tools, in: 2019 IEEE/ACM 41st International Conference on Software Engineering, ICSE, IEEE, 2019, pp. 430–441.

Cited By

Hong YTantithamthavorn CPasuksmit JThongtanunam PFriedman AZhao XKrasikov Ad'Amorim M(2024)Practitioners’ Challenges and Perceptions of CI Build Failure Predictions at AtlassianCompanion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering10.1145/3663529.3663856(370-381)Online publication date: 10-Jul-2024
https://dl.acm.org/doi/10.1145/3663529.3663856
Weeraddana NAlfadel MMcIntosh S(2024)Dependency-Induced Waste in Continuous Integration: An Empirical Study of Unused Dependencies in the npm EcosystemProceedings of the ACM on Software Engineering10.1145/36608231:FSE(2632-2655)Online publication date: 12-Jul-2024
https://dl.acm.org/doi/10.1145/3660823
Wang GSun ZChen YZhao YLiang QHao DChristakis MPradel M(2024)Commit Artifact Preserving Build PredictionProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3680356(1236-1248)Online publication date: 11-Sep-2024
https://dl.acm.org/doi/10.1145/3650212.3680356
Show More Cited By

Index Terms

Which builds are really safe to skip? Maximizing failure observation for build selection in continuous integration

Index terms have been assigned to the content through auto-classification.

Recommendations

A cost-efficient approach to building in continuous integration
ICSE '20: Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering

Continuous integration (CI) is a widely used practice in modern software engineering. Unfortunately, it is also an expensive practice --- Google and Mozilla estimate their CI systems in millions of dollars. In this paper, we propose a novel approach for ...
HybridCISave: A Combined Build and Test Selection Approach in Continuous Integration
Continuous Integration (CI) is a popular practice in modern software engineering. Unfortunately, it is also a high-cost practice—Google and Mozilla estimate their CI systems in millions of dollars. To reduce the computational cost in CI, researchers ...
Reducing cost in continuous integration with a collection of build selection approaches
ESEC/FSE 2021: Proceedings of the 29th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering

Continuous integration (CI) is a widely used practice in modern software engineering. Unfortunately, it is also an expensive practice — Google and Mozilla estimate their CI systems in millions of dollars. To reduce CI computation cost, I propose the ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image Journal of Systems and Software

Journal of Systems and Software Volume 188, Issue C

Jun 2022

289 pages

ISSN:0164-1212

Issue’s Table of Contents

Elsevier Inc.

Publisher

Elsevier Science Inc.

United States

Publication History

Published: 01 June 2022

Author Tags

Qualifiers

Research-article

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

13
Total Citations
View Citations
0
Total Downloads

Downloads (Last 12 months)0
Downloads (Last 6 weeks)0

Reflects downloads up to 23 Nov 2024

Other Metrics

View Author Metrics

Citations

Cited By

Hong YTantithamthavorn CPasuksmit JThongtanunam PFriedman AZhao XKrasikov Ad'Amorim M(2024)Practitioners’ Challenges and Perceptions of CI Build Failure Predictions at AtlassianCompanion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering10.1145/3663529.3663856(370-381)Online publication date: 10-Jul-2024
https://dl.acm.org/doi/10.1145/3663529.3663856
Weeraddana NAlfadel MMcIntosh S(2024)Dependency-Induced Waste in Continuous Integration: An Empirical Study of Unused Dependencies in the npm EcosystemProceedings of the ACM on Software Engineering10.1145/36608231:FSE(2632-2655)Online publication date: 12-Jul-2024
https://dl.acm.org/doi/10.1145/3660823
Wang GSun ZChen YZhao YLiang QHao DChristakis MPradel M(2024)Commit Artifact Preserving Build PredictionProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3680356(1236-1248)Online publication date: 11-Sep-2024
https://dl.acm.org/doi/10.1145/3650212.3680356
Zeng ZXiao TLamothe MHata HMcintosh SSpinellis DConstantinou EBacchelli A(2024)A Mutation-Guided Assessment of Acceleration Approaches for Continuous Integration: An Empirical Study of YourBaseProceedings of the 21st International Conference on Mining Software Repositories10.1145/3643991.3644914(556-568)Online publication date: 15-Apr-2024
https://dl.acm.org/doi/10.1145/3643991.3644914
Sun GHabchi SMcIntosh S(2024)RavenBuild: Context, Relevance, and Dependency Aware Build Outcome PredictionProceedings of the ACM on Software Engineering10.1145/36437711:FSE(996-1018)Online publication date: 12-Jul-2024
https://dl.acm.org/doi/10.1145/3643771
Sun GMeidani MHabchi SNayrolles MMcintosh SRoychoudhury APaiva AAbreu RStorey MAniche MNagappan N(2024)Code Impact Beyond Disciplinary Boundaries: Constructing a Multidisciplinary Dependency Graph and Analyzing Cross-Boundary ImpactProceedings of the 46th International Conference on Software Engineering: Software Engineering in Practice10.1145/3639477.3639726(122-133)Online publication date: 14-Apr-2024
https://dl.acm.org/doi/10.1145/3639477.3639726
Bouzenia IPradel MRoychoudhury APaiva AAbreu RStorey M(2024)Resource Usage and Optimization Opportunities in Workflows of GitHub ActionsProceedings of the IEEE/ACM 46th International Conference on Software Engineering10.1145/3597503.3623303(1-12)Online publication date: 20-May-2024
https://dl.acm.org/doi/10.1145/3597503.3623303
Kamath DFernandes EAdams BHassan A(2024)On combining commit grouping and build skip prediction to reduce redundant continuous integration activityEmpirical Software Engineering10.1007/s10664-024-10477-129:6Online publication date: 30-Aug-2024
https://dl.acm.org/doi/10.1007/s10664-024-10477-1
Silva GBezerra CUchôa AMachado I(2023)What Factors Affect the Build Failures Correction Time? A Multi-Project StudyProceedings of the 17th Brazilian Symposium on Software Components, Architectures, and Reuse10.1145/3622748.3622753(41-50)Online publication date: 25-Sep-2023
https://dl.acm.org/doi/10.1145/3622748.3622753
Fallahzadeh EBavand ARigby PChandra SBlincoe KTonella P(2023)Accelerating Continuous Integration with Parallel Batch TestingProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering10.1145/3611643.3616255(55-67)Online publication date: 30-Nov-2023
https://dl.acm.org/doi/10.1145/3611643.3616255
Show More Cited By

View Options

View options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

Media

Figures

Other

Tables

View Issue’s Table of Contents