On the Prediction of Software Merge Conflicts: A Systematic Review and Meta-analysis
ResumoContext: Predicting software merge conflicts plays a chief role in many software engineering tasks. Prediction techniques can be used to identify and anticipate potential conflicts between source code snippets that may arise when merging changes made by multiple developers. Problem: When multiple developers are working on the same source code, they may make changes to the same code snippets, which can cause conflicts when the changes are brought together. The problem is that typically these conflicts are difficult and time-consuming to resolve, and can potentially cause serious problems if not addressed properly. Solution: Predicting when conflicts will help in prioritizing or better managing the changes to be made in the code, in order to mitigate the emergence of conflicts. In this sense, developers can use tools that exam source codes to pinpoint potential snippets where conflicts are likely to occur. Theory of IS: This work was conceived under the aegis of the General Theory of Systems, in particular with regard to the interfaces between the parts of a system within its borders. In this case, the parts are themselves independent systems, called constituents, which include some information systems (IS). Method: This article focus on providing a systematic review and meta-analysis of published studies on the prediction of software conflicts. For this, we follow the PRISMA method. Contributions and Impact in the IS area: Development of a database knowledge of the historical context over predicting conflicts that will help in the development of future work and other research.
Ritu et al. Arora. 2020. Continuous Conflict Prediction during Collaborative Software Development: A step-before Continuous Integration. In Proceedings of the 3rd International Conference on Software Engineering and Information Management. 105–109.
Jacob T. et al. Biehl. 2007. FASTDash: A Visual Dashboard for Fostering Awareness in Software Teams. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (San Jose, California, USA) (CHI ’07). Association for Computing Machinery, New York, NY, USA, 1313–1322. https://doi.org/10.1145/1240624.1240823
Caius et al. Brindescu. 2020. An Empirical Investigation into Merge Conflicts and Their Effect on Software Quality. Empirical Software Engineering 25, 1 (jan 2020), 562–590. https://doi.org/10.1007/s10664-019-09735-4
Caius et al. Brindescu. 2020. Planning for Untangling: Predicting the Difficulty of Merge Conflicts. In 2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE). 801–811.
Yuriy et al. Brun. 2011. Proactive Detection of Collaboration Conflicts. In Proceedings of the 19th ACM SIGSOFT Symposium and the 13th European Conference on Foundations of Software Engineering (Szeged, Hungary) (ESEC/FSE ’11). Association for Computing Machinery, New York, NY, USA, 168–178. https://doi.org/10.1145/2025113.2025139
Yuriy et al. Brun. 2012. Predicting development trajectories to prevent collaboration conflicts. the Future of Collaborative Software Development (FCSD), Seattle, WA, USA (2012).
Yuriy et al. Brun. 2013. Early Detection of Collaboration Conflicts and Risks. IEEE Transactions on Software Engineering 39, 10 (2013), 1358–1375. https://doi.org/10.1109/TSE.2013.28
Catarina et al. Costa. 2021. Factors That Affect Merge Conflicts: A Software Developers’ Perspective. Association for Computing Machinery, New York, NY, USA, 233–242. https://doi.org/10.1145/3474624.3474641
Klissiomara Lopes DIAS. 2020. Towards requirements for merge conflict avoidance strategies. (2020).
Elizabeth et al. Dinella. 2022. Deepmerge: Learning to merge programs. IEEE Transactions on Software Engineering (2022).
H. Christian et al. Estler. 2013. Unifying Configuration Management with Merge Conflict Detection and Awareness Systems. In 2013 22nd Australian Software Engineering Conference. 201–210. https://doi.org/10.1109/ASWEC.2013.32
Klissiomara Dias et al.2020. Understanding predictive factors for merge conflicts. Information and Software Technology 121 (2020), 106256. https://doi.org/10.1016/j.infsof.2020.106256
Martin et al. Eyl. 2017. Prevent Collaboration Conflicts with Fine Grained Pessimistic Locking.. In MODELSWARD. 312–319.
Hongfei et al. Fan. 2012. Supporting Semantic Conflict Prevention in Real-Time Collaborative Programming Environments. SIGAPP Appl. Comput. Rev. 12, 2 (jun 2012), 39–52. https://doi.org/10.1145/2340416.2340420
Hongfei et al. Fan. 2017. Balancing Conflict Prevention and Concurrent Work in Real-Time Collaborative Programming. In Proceedings of the 12th Chinese Conference on Computer Supported Cooperative Work and Social Computing (Chongqing, China) (ChineseCSCW ’17). Association for Computing Machinery, New York, NY, USA, 217–220. https://doi.org/10.1145/3127404.3127447
Yuanrui et al. Fan. 2018. Early prediction of merged code changes to prioritize reviewing tasks. Empirical Software Engineering 23, 6 (2018), 3346–3393.
Kleinner et al. Farias. 2015. Evaluating the effort of composing design models: a controlled experiment. Software & Systems Modeling 14, 4 (2015), 1349–1365.
Gleiph et al. Ghiotto. 2018. On the nature of merge conflicts: A study of 2,731 open source Java projects hosted by GitHub. IEEE Transactions on Software Engineering 46, 8 (2018), 892–915.
Viral et al. Gupta. 2019. Predicting Code Merge Conflicts and Selecting Optimal Code Branching Strategy for Quality Improvement in Banking Sector. In System Performance and Management Analytics. Springer, 15–33.
Moein Owhadi Kareshk. 2020. Predicting Textual Merge Conflicts. https://doi.org/10.7939/r3-pzb7-2y14
Bakhtiar Khan Kasi. 2014. Minimizing Software Conflicts through Proactive Detection of Conflicts and Task Scheduling. In Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering (Hong Kong, China) (FSE 2014). Association for Computing Machinery, New York, NY, USA, 807–810. https://doi.org/10.1145/2635868.2666600
Barbara Ann et al. Kitchenham. 2022. SEGRESS: Software Engineering Guidelines for REporting Secondary Studies. IEEE Transactions on Software Engineering (2022).
Olaf et al. Lebenich. 2018. Indicators for Merge Conflicts in the Wild: Survey and Empirical Study. Automated Software Engg. 25, 2 (jun 2018), 279–313. https://doi.org/10.1007/s10515-017-0227-0
José William et al. Menezes. 2020. What causes merge conflicts?. In Proceedings of the 34th Brazilian Symposium on Software Engineering. 203–212.
José William et al. Menezes. 2021. Attributes that may raise the occurrence of merge conflicts. Journal of Software Engineering Research and Development 9, 1 (Oct. 2021), 14:1 – 14:14. https://doi.org/10.5753/jserd.2021.1911
Tom Mens. 2002. A state-of-the-art survey on software merging. IEEE transactions on software engineering 28, 5 (2002), 449–462.
Moein et al. Owhadi-Kareshk. 2019. Predicting merge conflicts in collaborative software development. In 2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). IEEE, 1–11.
Matthew J et al. Page. 2021. The PRISMA 2020 statement: an updated guideline for reporting systematic reviews. Systematic reviews 10, 1 (2021), 1–11.
Kai et al. Petersen. 2008. Systematic mapping studies in software engineering. In 12th International Conference on Evaluation and Assessment in Software Engineering (EASE) 12. 1–10.
Kai et al. Petersen. 2015. Guidelines for conducting systematic mapping studies in software engineering: An update. Information and software technology 64 (2015), 1–18.
Thaís Alves Burity Rocha. 2020. Avoiding merge conflicts by test-based task prioritization. https://repositorio.ufpe.br/handle/123456789/37667
Thaís et al. Rocha. 2019. Using acceptance tests to predict files changed by programming tasks. Journal of Systems and Software 154 (2019), 176–195.
Christoffer et al. Rosen. 2015. Commit Guru: Analytics and Risk Prediction of Software Commits. In Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering (Bergamo, Italy) (ESEC/FSE 2015). Association for Computing Machinery, New York, NY, USA, 966–969. https://doi.org/10.1145/2786805.2803183
Nishrith Saini and Ricardo Britto. 2021. Using Machine Intelligence to Prioritise Code Review Requests. In Proceedings of the 43rd International Conference on Software Engineering: Software Engineering in Practice (Virtual Event, Spain) (ICSE-SEIP ’21). IEEE Press, 11–20. https://doi.org/10.1109/ICSE-SEIP52600.2021.00010
João Pedro et al. Santos. 2019. Improving the Prediction of Files Changed by Programming Tasks. In Proceedings of the XIII Brazilian Symposium on Software Components, Architectures, and Reuse (Salvador, Brazil) (SBCARS ’19). Association for Computing Machinery, New York, NY, USA, 53–62. https://doi.org/10.1145/3357141.3357145
Anita et al. Sarma. 2012. Palantir: Early Detection of Development Conflicts Arising from Parallel Code Changes. IEEE Transactions on Software Engineering 38, 4 (2012), 889–908. https://doi.org/10.1109/TSE.2011.64
Marina Bianca Trif and Radu Razvan Slavescu. 2021. Towards Predicting Merge Conflicts in Software Development Environments. In 2021 IEEE 17th International Conference on Intelligent Computer Communication and Processing (ICCP). 251–256. https://doi.org/10.1109/ICCP53602.2021.9733512
Romi Satria Wahono. 2015. A systematic literature review of software defect prediction. Journal of Software Engineering 1, 1 (2015), 1–16.
Thorsten et al. Wuensche. 2020. Detecting Higher-Order Merge Conflicts in Large Software Projects. In 2020 IEEE 13th International Conference on Software Testing, Validation and Verification (ICST). 353–363. https://doi.org/10.1109/ICST46399.2020.00043