-
Notifications
You must be signed in to change notification settings - Fork 9
/
Copy pathversion-control.bib
1825 lines (1444 loc) · 93.8 KB
/
version-control.bib
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
% Bibliography about version control and merge conflicts
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Diff
%%%
@inproceedings{DBLP:conf/c++/Grass92,
author = {Judith E. Grass},
title = {Cdiff: {A} Syntax Directed Differencer for {C++} Programs},
booktitle = {Proceedings of the {C++} Conference. Portland, OR, USA, August 1992},
pages = {181--194},
year = {1992},
timestamp = {Thu, 15 May 2014 18:36:26 +0200},
biburl = {https://dblp.org/rec/conf/c++/Grass92.bib},
bibsource = {dblp computer science bibliography, https://dblp.org}
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Diff -- line-based
%%%
@Article{NugrohoHM2020,
author = "Nugroho, Yusuf Sulistyo and Hata, Hideaki and Matsumoto, Kenichi",
title = "How different are different \emph{diff} algorithms in {Git}?",
journal = JEmpiricalSE,
year = 2020,
volume = 25,
number = 1,
pages = "790-823",
month = jan,
abstract =
"Automatic identification of the differences between two versions of a file is a
common and basic task in several applications of mining code repositories. Git,
a version control system, has a diff utility and users can select algorithms of
diff from the default algorithm Myers to the advanced Histogram algorithm. From
our systematic mapping, we identified three popular applications of diff in
recent studies. On the impact on code churn metrics in 14 Java projects, we
obtained different values in 1.7\% to 8.2\% commits based on the different diff
algorithms. Regarding bug-introducing change identification, we found 6.0\% and
13.3\% in the identified bug-fix commits had different results of
bug-introducing changes from 10 Java projects. For patch application, we found
that the Histogram is more suitable than Myers for providing the changes of
code, from our manual analysis. Thus, we strongly recommend using the Histogram
algorithm when mining Git repositories to consider differences in source code.",
}
@Misc{Cohen2010,
author = "Bram Cohen",
title = "Patience diff advantages",
howpublished = "\url{https://bramcohen.livejournal.com/73318.html}",
month = mar,
year = 2010,
}
@Misc{PlumeLibMerging,
author = "Michael D. Ernst",
title = "Plume-lib merging: merge drivers and merge tools",
howpublished = "\url{https://github.com/plume-lib/merging}",
month = sep,
year = 2024,
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Diff -- tree-based
%%%
%%% Tree diff: Surveys
@InProceedings{Peters2005,
author = "Luuk Peters",
title = "Change detection in {XML} trees: a survey",
booktitle = "3rd Twente Student Conference on IT",
year = 2005,
month = jun,
address = "Enschede, The Netherlands",
}
%%% Tree diff: Papers other than surveys
@InProceedings{FalleriMBMM2014,
author = "Falleri, Jean-R\'{e}my and Morandat, Flor\'{e}al and Blanc, Xavier and Martinez, Matias and Monperrus, Martin",
authorASCII = "Falleri, Jean-Remy and Morandat, Floreal and Blanc, Xavier and Martinez, Matias and Monperrus, Martin",
title = "Fine-grained and accurate source code differencing",
crossref = "ASE2014",
pages = "313-324",
}
@inproceedings{10.1145/3238147.3238219,
author = {Huang, Kaifeng and Chen, Bihuan and Peng, Xin and Zhou, Daihong and Wang, Ying and Liu, Yang and Zhao, Wenyun},
title = {ClDiff: Generating Concise Linked Code Differences},
year = {2018},
isbn = {9781450359375},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3238147.3238219},
doi = {10.1145/3238147.3238219},
abstract = {Analyzing and understanding source code changes is important in a variety of software maintenance tasks. To this end, many code differencing and code change summarization methods have been proposed. For some tasks (e.g. code review and software merging), however, those differencing methods generate too fine-grained a representation of code changes, and those summarization methods generate too coarse-grained a representation of code changes. Moreover, they do not consider the relationships among code changes. Therefore, the generated differences or summaries make it not easy to analyze and understand code changes in some software maintenance tasks. In this paper, we propose a code differencing approach, named CLDIFF, to generate concise linked code differences whose granularity is in between the existing code differencing and code change summarization methods. The goal of CLDIFF is to generate more easily understandable code differences. CLDIFF takes source code files before and after changes as inputs, and consists of three steps. First, it pre-processes the source code files by pruning unchanged declara- tions from the parsed abstract syntax trees. Second, it generates concise code differences by grouping fine-grained code differences at or above the statement level and describing high-level changes in each group. Third, it links the related concise code differences according to five pre-defined links. Experiments with 12 Java projects (74,387 commits) and a human study with 10 participants have indicated the accuracy, conciseness, performance and usefulness of CLDIFF.},
booktitle = {Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering},
pages = {679-690},
numpages = {12},
keywords = {Code Differencing, Program Comprehension, AST},
location = {Montpellier, France},
series = {ASE '18}
}
@inproceedings{10.1007/11802167_104,
author = {Lee, Suk Kyoon and Kim, Dong Ah},
title = {X-Tree Diff+: efficient change detection algorithm in XML documents},
year = {2006},
isbn = {3540366792},
publisher = {Springer-Verlag},
address = {Berlin, Heidelberg},
url = {https://doi.org/10.1007/11802167_104},
doi = {10.1007/11802167_104},
abstract = {As web documents proliferate fast, the need for real-time computation of change (edit script) between web documents increases. Though fast heuristic algorithms have been proposed recently, the qualities of edit scripts produced by them are not satisfactory. In this paper, we propose X-tree Diff+ which produces better quality of edit scripts by introducing a tuning step based on the notion of consistency of matching. We also add copy operation to provide users more convenience. Tuning and copy operation increase matching ratio drastically. X-tree Diff+ produces better quality of edit scripts and runs fast equivalent to the time complexity of fastest heuristic algorithms},
booktitle = {Proceedings of the 2006 International Conference on Embedded and Ubiquitous Computing},
pages = {1037-1046},
numpages = {10},
location = {Seoul, Korea},
series = {EUC'06}
}
@InProceedings{LindholmKT2006,
author = "Lindholm, Tancred and Kangasharju, Jaakko and Tarkoma, Sasu",
title = "Fast and simple {XML} tree differencing by sequence alignment",
crossref = "DocEng2006",
pages = "75-84",
abstract =
"With the advent of XML we have seen a renewed interest in methods for
computing the difference between trees. Methods that include heuristic
elements play an important role in practical applications due to the inherent
complexity of the problem. We present a method for differencing XML as ordered
trees based on mapping the problem to the domain of sequence alignment,
applying simple and efficient heuristics in this domain, and transforming back
to the tree domain. Our approach provides a method to quickly compute changes
that are meaningful transformations on the XML tree level, and includes
subtree move as a primitive operation. We evaluate the feasibility of our
approach and benchmark it against a selection of existing differencing
tools. The results show our approach to be feasible and to have the potential
to perform on par with tools of a more complex design in terms of both output
size and execution time.",
}
@InProceedings{RimonS2005,
author = "Mikhaiel, Rimon and Stroulia, Eleni",
title = "Accurate and efficient {HTML} differencing",
booktitle = "STEP'05: 13th IEEE International Workshop on Software Technology and Engineering Practice",
year = 2005,
pages = "163-172",
}
@InProceedings{CobenaAM2002,
author = "Cob{\'e}ena, Gr{\'e}gory and Abiteboul, Serge and Marian, Am{\'e}lie",
authorASCII = "Cobeena, Gregory and Abiteboul, Serge and Marian, Amelie",
title = "Detecting changes in {XML} documents",
crossref = "ICDE2002",
pages = "41-52",
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Diff -- graph-based
%%%
@InProceedings{ApiwattanapongOH2004,
author = "Taweesup Apiwattanapong and Alessandro Orso and Mary Jean Harrold",
title = "A differencing algorithm for object-oriented programs",
crossref = "ASE2004",
pages = "2--13",
abstract =
"During software evolution, information about changes between different
versions of a program is useful for a number of software engineering
tasks. For many of these tasks, a purely syntactic differencing may not
provide enough information for the task to be performed effectively. This
problem is especially relevant in the case of object-oriented software, for
which a syntactic change can have subtle and unforeseen effects. In this
paper, we present a technique for comparing object-oriented programs that
identifies both differences and correspondences between two versions of a
program. The technique is based on a representation that handles
object-oriented features and, thus, can capture the behavior of
object-oriented programs. We also present JDIFF, a tool that implements the
technique for Java programs, and empirical results that show the efficiency
and effectiveness of the technique on a real program.",
supersededby = "ApiwattanapongOH2007",
}
@Article{ApiwattanapongOH2007,
author = "Taweesup Apiwattanapong and Alessandro Orso and Mary Jean Harrold",
title = "{JD}iff: A differencing technique and tool for object-oriented programs",
journal = ASEjournal,
year = 2007,
volume = 14,
month = mar,
pages = "3--36",
abstract =
"During software evolution, information about changes between different
versions of a program is useful for a number of software engineering
tasks. For example, configuration-management systems can use change
information to assess possible conflicts among updates from different
users. For another example, in regression testing, knowledge about which
parts of a program are unchanged can help in identifying test cases that
need not be rerun. For many of these tasks, a purely syntactic differencing
may not provide enough information for the task to be performed
effectively. This problem is especially relevant in the case of
object-oriented software, for which a syntactic change can have subtle and
unforeseen effects. In this paper, we present a technique for comparing
object-oriented programs that identifies both differences and
correspondences between two versions of a program. The technique is based
on a representation that handles object-oriented features and, thus, can
capture the behavior of object-oriented programs. We also present JDiff, a
tool that implements the technique for Java programs. Finally, we present
the results of four empirical studies, performed on many versions of two
medium-sized subjects, that show the efficiency and effectiveness of the
technique when used on real programs.",
usesDaikonAsTestSubject = 1,
downloads = "http://dx.doi.org/10.1007/s10515-006-0002-0 DOI",
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Diff -- other representations
%%%
@InProceedings{JacksonL1994,
author = "Daniel Jackson and David A. Ladd",
title = "Semantic diff: a tool for summarizing the effects of modifications",
crossref = "ICSM94",
pages = "243-252",
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Merging
%%%
@Article{Mens2002,
author = "Tom Mens",
title = "A state-of-the-art survey on software merging",
journal = IEEETSE,
year = 2002,
volume = 28,
number = 5,
pages = "449-462",
doi = "10.1109/TSE.2002.1000449",
}
@InProceedings{KudrjavetsNR2022,
author = "Kudrjavets, Gunnar and Nagappan, Nachiappan and Rastogi, Ayushi",
title = "Do Small Code Changes Merge Faster? A Multi-Language Empirical Investigation",
crossref = "MSR2022",
pages = "537-548",
abstract = {Code velocity, or the speed with which code changes are integrated into a production environment, plays a crucial role in Continuous Integration and Continuous Deployment. Many studies report factors influencing code velocity. However, solutions to increase code velocity are unclear. Meanwhile, the industry continues to issue guidelines on "ideal" code change size, believing it increases code velocity despite lacking evidence validating the practice. Surprisingly, this fundamental question has not been studied to date. This study investigates the practicality of improving code velocity by optimizing pull request size and composition (ratio of insertions, deletions, and modifications).
\par
We start with a hypothesis that a moderate correlation exists between pull request size and time-to-merge. We selected 100 most popular, actively developed projects from 10 programming languages on GitHub. We analyzed our dataset of 845,316 pull requests by size, composition, and context to explore its relationship to time-to-merge---a proxy to measure code velocity. Our study shows that pull request size and composition do not relate to time-to-merge. Regardless of the contextual factors that can influence pull request size or composition (e.g., programming language), the observation holds. Pull request data from two other platforms: Gerrit and Phabricator (401,790 code reviews) confirms the lack of relationship. This negative result as in "...eliminate useless hypotheses ..." [75] challenges a widespread belief by showing that small code changes do not merge faster to increase code velocity.},
}
@InProceedings{MenezesTPMPMC2020,
author = "Menezes, Jos\'{e} William and Trindade, Bruno and Pimentel, Jo\~{a}o Felipe and Moura, Tayane and Plastino, Alexandre and Murta, Leonardo and Costa, Catarina",
title = "What Causes Merge Conflicts?",
crossref = "SBES2020",
pages = "203-212",
abstract = {During the software development process, several developers commonly change artifacts in parallel. A merge process can combine parallel changes. In the case of changes that cannot be automatically combined, the developer responsible for the merge must reconcile decisions and resolve conflicts. Some studies are concerned with investigating ways to deal with merge conflicts and measuring the effort that this activity may require. However, the investigation of factors that may reduce the occurrence of conflicts needs more and deeper attention. This paper aims at identifying and analyzing attributes of past merges with and without conflicts to understand what may induce physical conflicts. We analyzed 182,273 merge scenarios from 80 projects written in eight different programming languages to find characteristics that increase the chances of a merge to have a conflict. We found that attributes such as the number of committers, the number of commits, and the number of changed files seem to have the biggest influence in the occurrence of merge conflicts. Moreover, attributes in the branch that is being integrated seem to be more influential than the same attributes in the other branch. Additionally, we discovered positive correlations between the occurrence of conflicts and both the duration of the branch and the intersection of developers.},
}
@Article{ShenGHM2023,
author = {Shen, Bowen and Gulzar, Muhammad Ali and He, Fei and Meng, Na},
title = {A Characterization Study of Merge Conflicts in {Java} Projects},
journal = TOSEM,
year = 2023,
volume = 32,
number = 2,
pages = {40:1-28},
month = mar,
abstract =
{In collaborative software development, programmers create software branches
to add features and fix bugs tentatively, and then merge branches to
integrate edits. When edits from different branches textually overlap (i.e.,
textual conflicts) or lead to compilation and runtime errors (i.e., build
and test conflicts), it is challenging for developers to remove such
conflicts. Prior work proposed tools to detect and solve conflicts. They
investigate how conflicts relate to code smells and the software development
process. However, many questions are still not fully investigated, such as
what types of conflicts exist in real-world applications and how developers
or tools handle them. For this article, we used automated textual merge,
compilation, and testing to reveal three types of conflicts in 208
open-source repositories: textual conflicts, build conflicts (i.e.,
conflicts causing build errors), and test conflicts (i.e., conflicts
triggering test failures). We manually inspected 538 conflicts and their
resolutions to characterize merge conflicts from different angles. Our
analysis revealed three interesting phenomena. First, higher-order conflicts
(i.e., build and test conflicts) are harder to detect and resolve, while
existing tools mainly focus on textual conflicts. Second, developers
manually resolved most higher-order conflicts by applying similar edits to
multiple program locations; their conflict resolutions share common editing
patterns implying great opportunities for future tool design. Third,
developers resolved 64\% of true textual conflicts by keeping complete edits
from either a left or right branch. Unlike prior studies, our research for
the first time thoroughly characterizes three types of conflicts, with a
special focus on higher-order conflicts and limitations of existing tool
design. Our work will shed light on future research of software merge.},
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Merging -- line-based
%%%
@Article{PerrySV2001,
author = "Perry, Dewayne E. and Siy, Harvey P. and Votta, Lawrence G.",
title = "Parallel changes in large-scale software development: an observational case study",
journal = TOSEM,
year = 2001,
volume = 10,
number = 3,
pages = "308-337",
month = "jul",
abstract = {An essential characteristic of large-scale software development is parallel development by teams of developers. How this parallel development is structured and supported has a profound effect on both the quality and timeliness of the product. We conduct an observational case study in which we collect and analyze the change and configuration management history of a legacy system to delineate the boundaries of, and to understand the nature of, the problems encountered in parallel development. The results of our studies are (1) that the degree of parallelism is very high -- higher than considered by tool builders; (2) there are multiple levels of parallelism, and the data for some important aspects are uniform and consistent for all levels; (3) the tails of the distributions are long, indicating the tail, rather than the mean, must receive serious attention in providing solutions for these problems; and (4) there is a significant correlation between the degree of parallel work on a given component and the number of quality problems it has. Thus, the results of this study are important both for tool builders and for process and project engineers.},
}
@Article{GhiottoMBvdH2020,
author = "Ghiotto, Gleiph and Murta, Leonardo and Barros, M{\'a}rcio and van der Hoek, Andr{\'e}",
authorUTF = "Ghiotto, Gleiph and Murta, Leonardo and Barros, Márcio and van der Hoek, André",
authorASCII = "Ghiotto, Gleiph and Murta, Leonardo and Barros, Marcio and van der Hoek, Andre",
title = "On the Nature of Merge Conflicts: A Study of 2,731 Open Source {Java} Projects Hosted by {GitHub}",
journal = ieeetse,
year = 2020,
volume = 46,
number = 8,
pages = "892-915",
month = aug,
}
@Article{SeibtHCBA2022,
author = "Seibt, Georg and Heck, Florian and Cavalcanti, Guilherme and Borba, Paulo and Apel, Sven",
title = "Leveraging Structure in Software Merge: An Empirical Study",
journal = IEEETSE,
year = 2022,
volume = 48,
number = 11,
pages = "4590-4610",
}
@InProceedings{NguyenI2017,
author = "Hoai Le Nguyen and Claudia-Lavinia Ignat",
title = "Parallelism and conflicting changes in {Git} version control systems",
booktitle = "IWCES'17 - The Fifteenth International Workshop on Collaborative Editing Systems",
year = 2017,
month = feb,
address = "Portland, OR, USA",
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Merging -- tree-based (including "structured" and "semi-structured")
%%%
@InProceedings{Asklund1994,
author = "Ulf Asklund",
title = "Identifying conflicts during structural merge",
booktitle = "NWPER 1994, Nordic Workshop on Programming Environment Research",
year = 1994,
pages = "231-242",
month = jun,
}
@InProceedings{HuntT2002,
author = "J. J. Hunt and W. F. Tichy",
title = "Extensible language-aware merging",
crossref = "ICSM2002",
pages = "511-520",
}
@InProceedings{ApelLBLK2011,
author = "Sven Apel and J{\"o}rg Liebig and Benjamin Brandl and Christian Lengauer and Christian K{\"a}stner",
authorASCII = "Sven Apel and Jorg Liebig and Benjamin Brandl and Christian Lengauer and Christian Kastner",
title = "Semistructured Merge: Rethinking Merge in Revision Control Systems",
crossref = "FSE2011",
pages = "190--200",
}
@InProceedings{TrindadeTavaresBCS2019,
author = "Trindade Tavares, Alberto and Borba, Paulo and Cavalcanti, Guilherme and Soares, S{\'e}rgio",
authorUTF = "Trindade Tavares, Alberto and Borba, Paulo and Cavalcanti, Guilherme and Soares, Sérgio",
authorASCII = "Trindade Tavares, Alberto and Borba, Paulo and Cavalcanti, Guilherme and Soares, Sergio",
title = "Semistructured Merge in {JavaScript} Systems",
crossref = "ASE2019",
pages = "1014-1025",
}
@InProceedings{ApelLL2012,
author = "Apel, Sven and Le{\ss}enich, Olaf and Lengauer, Christian",
authorUTF = "Apel, Sven and Leßenich, Olaf and Lengauer, Christian",
authorASCII = "Apel, Sven and Lessenich, Olaf and Lengauer, Christian",
title = "Structured merge with auto-tuning: balancing precision and performance",
crossref = "ICSE2012",
pages = "120-129",
}
@Article{LessenichAL2014,
author = "Olaf Le{\ss}enich and Sven Apel and Christian Lengauer",
authorASCII = "Olaf Lessenich and Sven Apel and Christian Lengauer",
title = "Balancing precision and performance in structured merge",
journal = JASE,
year = 2014,
volume = 22,
number = 3,
pages = "367-397",
month = may,
}
@InProceedings{CavalcantiBA2017,
author = "Cavalcanti, Guilherme and Borba, Paulo and Accioly, Paola",
title = "Evaluating and improving semistructured merge",
crossref = "OOPSLA2017",
pages = "59:1-59:27",
}
@InProceedings{AsenovGMO2017,
author = "Asenov, Dimitar and Guenat, Balz and M{\"u}ller, Peter and Otth, Martin",
title = "Precise Version Control of Trees with Line-Based Version Control Systems",
crossref = "FASE2017",
pages = "152-169",
abstract=
"Version control of tree structures, ubiquitous in software engineering, is
typically performed on a textual encoding of the trees, rather than the trees
directly. Applying standard line-based diff and merge algorithms to such
encodings leads to inaccurate diffs, unnecessary conflicts, and incorrect
merges. To address these problems, we propose novel algorithms for computing
precise diffs between two versions of a tree and for three-way merging of
trees. Unlike most other approaches for version control of structured data,
our approach integrates with mainstream version control systems. Our merge
algorithm can be customized for specific application domains to further
improve merge results. An evaluation of our approach on abstract syntax trees
from popular Java projects shows substantially improved merge results
compared to Git.",
}
@inproceedings{10.1145/1860559.1860600,
author = {Vion-Dury, Jean-Yves},
title = {Diffing, Patching and Merging XML Documents: Toward a Generic Calculus of Editing Deltas},
year = {2010},
isbn = {9781450302319},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1860559.1860600},
doi = {10.1145/1860559.1860600},
abstract = {This work addresses what we believe to be a central issue in the field of XML diff and merge computation: the mathematical modeling of the so-called "editing deltas" and the study of their formal abstract properties. We expect at least three outputs from this theoretical work: a common basis to compare performances of the various algorithms through a structural normalization of deltas, a universal and flexible patch application model and a clearer separation of patch and merge engine performance from delta generation performance. Moreover, this work could inspire technical approaches to combine heterogeneous engines thank to sound delta transformations. This short paper reports current results, discusses key points and outlines some perspectives.},
booktitle = {Proceedings of the 10th ACM Symposium on Document Engineering},
pages = {191-194},
numpages = {4},
keywords = {tree transformation, tree-to-tree correction, version control, XML, tree edit distance},
location = {Manchester, United Kingdom},
series = {DocEng '10}
}
@inproceedings{10.1145/2494266.2494277,
author = {Ba, M. Lamine and Abdessalem, Talel and Senellart, Pierre},
title = {Uncertain Version Control in Open Collaborative Editing of Tree-Structured Documents},
year = {2013},
isbn = {9781450317894},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2494266.2494277},
doi = {10.1145/2494266.2494277},
abstract = {In order to ease content enrichment, exchange, and sharing, web-scale collaborative platforms such as Wikipedia or Google Docs enable unbounded interactions between a large number of contributors, without prior knowledge of their level of expertise and reliability. Version control is then essential for keeping track of the evolution of the shared content and its provenance. In such environments, uncertainty is ubiquitous due to the unreliability of the sources, the incompleteness and imprecision of the contributions, the possibility of malicious editing and vandalism acts, etc. To handle this uncertainty, we use a probabilistic XML model as a basic component of our version control framework. Each version of a shared document is represented by an XML tree and the whole document, together with its different versions, is modeled as a probabilistic XML document. Uncertainty is evaluated using the probabilistic model and the reliability measure associated to each source, each contributor, or each editing event, resulting in an uncertainty measure on each version and each part of the document. We show that standard version control operations can be implemented directly as operations on the probabilistic XML model; efficiency with respect to deterministic version control systems is demonstrated on real-world datasets.},
booktitle = {Proceedings of the 2013 ACM Symposium on Document Engineering},
pages = {27-36},
numpages = {10},
keywords = {xml, collaborative work, uncertain data, version control},
location = {Florence, Italy},
series = {DocEng '13}
}
@Article{LarsenFBM2023,
author = "Lars{\'e}n, Simon and Falleri, Jean-R{\'e}my and Baudry, Benoit and Monperrus, Martin",
title = "Spork: Structured Merge for {Java} with Formatting Preservation",
journal = IEEETSE,
year = 2023,
volume = 49,
number = 01,
pages = "64-83",
month = jan,
}
@InProceedings{ZHY2019,
author = "Fengmin Zhu and Fei He and Qianshan Yu",
title = "Enhancing precision of structured merge by proper tree matching",
crossref = "ICSECompanion2019",
pages = "286-287",
}
@Misc{Hume2017,
author = "Tristan Hume",
title = "Designing a tree diff algorithm using dynamic programming and {A*}",
howpublished = "\url{https://thume.ca/2017/06/17/tree-diffing/}",
year = 2017,
}
@InProceedings{Lindholm2004,
author = "Tancred Lindholm",
title = "A three-way merge for {XML} documents",
booktitle = "DocEng",
year = 2004,
NEEDpages = "*",
}
@InProceedings{BakaoukasB2020,
author = "Bakaoukas, Anastasios G. and Bakaoukas, Nikolaos G.",
title = "A Top-Down Three-Way Merge Algorithm for {HTML/XML} Documents",
booktitle = "IntelliSys 2020: Intelligent Systems and Applications: Proceedings of the 2020 Intelligent Systems Conference",
year = 2020,
pages = "75-96",
abstract =
"Collaborative work, with the need to keep HTML/XML code up-to-date, is now
becoming vital particularly in the Web Development field. In order to fully
support collaborative work and resolve related problems the need has arisen
for an optimum solution to the automated editing of a number of parallel
copies originating from a single original HTML/XML code document with the
additional requirement to subsequently merge the copies into a single updated
document. A number of algorithms have been used in the past for the purpose,
such as: Diff3, XmlDiff, DeltaXML {\&} 3DM, but HTML/XML code complexity
related issues have now called for an algorithm that is more specifically
designed for the purpose. In this paper a new algorithmic approach to merging
HTML/XML code documents is presented that is based on the ``Three-way Merge''
approach and the ``Node-per-Node'' comparison between ordered trees. For the
creation of the actual merging function operating at the heart of the
algorithm, a particular methodology was followed in which only the two
``Current Versions'' are required for the generation of the updated document,
and no involvement of the ``Original Document'' is necessary. This is an
important improvement over the currently existing algorithms because
eliminates the well-known ``Idempotent'' problem in merging two HTML/XML
documents. In addition, the algorithmic approach presented here allows for the
identification and treatment of all the conflicts that arise during a HTML/XML
code merging in an ordered and clearly specified manner.",
}
@InProceedings{SkafMolliMRN2008,
author = "Skaf-Molli, Hala and Molli, Pascal and Rahhal, Charbel and Naja-Jazzar, Hala",
title = "Collaborative Writing of {XML} Documents",
pages = "1-6",
crossref = "ICTTA2008",
year = 2008,
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Merging -- graph-based
%%%
@InProceedings{HorwitzPR88a,
author = "Susan Horwitz and Jan Prins and Thomas Reps",
title = "Integrating non-interfering versions of programs",
crossref = "POPL88",
pages = "146--157",
}
@Article{HorwitzPR89:TOPLAS,
author = "Susan Horwitz and Jan Prins and Thomas Reps",
title = "Integrating non-interfering versions of programs",
journal = toplas,
year = 1989,
volume = 11,
number = 3,
pages = "345--387",
month = jul
}
@TechReport{Binkley91,
author = "David W. Binkley",
title = "Multi-Procedure Program Integration",
institution = UWMadison,
year = 1991,
number = 1038,
month = Aug
}
@inproceedings{10.1145/1826147.1826154,
author = {Koegel, Maximilian and Herrmannsdoerfer, Markus and von Wesendonk, Otto and Helming, Jonas},
title = {Operation-Based Conflict Detection},
year = {2010},
isbn = {9781605589602},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1826147.1826154},
doi = {10.1145/1826147.1826154},
abstract = {In recent years, models are increasingly used throughout the entire lifecycle in software engineering projects. In effect, the need for collaboration and for management of change on these models emerged. Traditionally, Software Configuration Management (SCM) systems are employed to facilitate collaboration on software engineering artifacts and to control change to these artifacts. For scalability and to support offline operation, most of these systems employ optimistic concurrency control and therefore require methods to detect concurrent change---also known as conflict detection. However, many researchers have shown that existing approaches for SCM systems do not work well on graph-like models, since they are geared towards textual artifacts and do not take the graph structure of models into account. The approaches for conflict detection in these systems show many false positives, since they require a merge every time the same configuration item --- in this case the same file --- is changed. In this paper, we propose operation-based conflict detection, which detects conflicts directly on the operations that change the model. We compare operation-based conflict detection to file-based conflict detection in a multi-case study and show that operation-based conflict detection results in less conflicts and therefore requires fewer merges.},
booktitle = {Proceedings of the 1st International Workshop on Model Comparison in Practice},
pages = {21-30},
numpages = {10},
keywords = {conflict detection, model merging, software configuration management, operation-based, version control},
location = {Malaga, Spain},
series = {IWMCP '10}
}
@inproceedings{10.1109/CVSM.2009.5071721,
author = {Koegel, Maximilian and Helming, Jonas and Seyboth, Stephan},
title = {Operation-Based Conflict Detection and Resolution},
year = {2009},
isbn = {9781424437146},
publisher = {IEEE Computer Society},
address = {USA},
url = {https://doi.org/10.1109/CVSM.2009.5071721},
doi = {10.1109/CVSM.2009.5071721},
abstract = {Models are in wide-spread use in the software development lifecycle and model-driven development even promotes them from an abstraction of the system to the description the system is generated from. Therefore it is increasingly important to collaborate on models. These models can range from requirements models over UML models to project management models such as schedules. Tool support for collaboration on models is therefore crucial. Traditionally Software Configuration Management (SCM) systems such as RCS [9] or Subversion [10] have supported this task for textual artifacts such as source code on the granularity of files and textual lines. They do not work well for graph-like models with many links since the granularity needed to support them is on the level of model elements and their attributes. For the design of a novel SCM system addressing these requirements it is essential to define how conflicts on models are detected and how they can be resolved. In this paper we present an approach to conflict detection and resolution on models. We employ operation-based change tracking and therefore detect conflicts based on operations. For conflict resolution we propose an integration of SCM with techniques from Rational Management to effectively resolve conflicts.},
booktitle = {Proceedings of the 2009 ICSE Workshop on Comparison and Versioning of Software Models},
pages = {43-48},
numpages = {6},
series = {CVSM '09}
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Merging -- neural, deep learning
%%%
@Article{DinellaMSBNL2023,
author = "Dinella, Elizabeth and Mytkowicz, Todd and Svyatkovskiy, Alexey and Bird, Christian and Naik, Mayur and Lahiri, Shuvendu",
title = "{DeepMerge}: Learning to merge programs",
journal = TSE,
year = 2023,
volume = 49,
number = 4,
pages = "1599–1614",
month = apr,
abstract =
"In collaborative software development, program merging is \emph{the}
mechanism to integrate changes from multiple programmers. Merge algorithms
in modern version control systems report a conflict when changes interfere
textually. Merge conflicts require manual intervention and frequently stall
modern continuous integration pipelines. Prior work found that, although
costly, a large majority of resolutions involve re-arranging text without
writing any new code. Inspired by this observation we propose the
\emph{first data-driven approach} to resolve merge conflicts with a machine
learning model. We realize our approach in a tool DeepMerge that uses a
novel combination of (i) an edit-aware embedding of merge inputs and (ii) a
variation of pointer networks, to construct resolutions from input
segments. We also propose an algorithm to localize manual resolutions in a
resolved file and employ it to curate a ground-truth dataset comprising
8,719 non-trivial resolutions in JavaScript programs. Our evaluation shows
that, on a held out test set, DeepMerge can predict correct resolutions for
37\% of non-trivial merges, compared to only 4\% by a state-of-the-art
semistructured merge technique. Furthermore, on the subset of merges with
upto 3 lines (comprising 24\% of the total dataset), DeepMerge can predict
correct resolutions with 78\% accuracy.",
}
@InProceedings{SvyatkovskiyFGMDBJSL2022,
author = "Svyatkovskiy, Alexey and Fakhoury, Sarah and Ghorbani, Negar and Mytkowicz, Todd and Dinella, Elizabeth and Bird, Christian and Jang, Jinu and Sundaresan, Neel and Lahiri, Shuvendu K.",
title = "Program Merge Conflict Resolution via Neural Transformers",
crossref = "FSE2022",
pages = "822-833",
abstract =
"Collaborative software development is an integral part of the modern
software development life cycle, essential to the success of large-scale
software projects. When multiple developers make concurrent changes around
the same lines of code, a merge conflict may occur. Such conflicts stall
pull requests and continuous integration pipelines for hours to several
days, seriously hurting developer productivity. To address this problem, we
introduce MergeBERT, a novel neural program merge framework based on
token-level three-way differencing and a transformer encoder model. By
exploiting the restricted nature of merge conflict resolutions, we
reformulate the task of generating the resolution sequence as a
classification task over a set of primitive merge patterns extracted from
real-world merge commit data. Our model achieves 63-68\% accuracy for merge
resolution synthesis, yielding nearly a 3\texttimes{} performance
improvement over existing semi-structured, and 2\texttimes{} improvement
over neural program merge tools. Finally, we demonstrate that MergeBERT is
sufficiently flexible to work with source code files in Java, JavaScript,
TypeScript, and C# programming languages. To measure the practical use of
MergeBERT, we conduct a user study to evaluate MergeBERT suggestions with
25 developers from large OSS projects on 122 real-world conflicts they
encountered. Results suggest that in practice, MergeBERT resolutions would
be accepted at a higher rate than estimated by automatic metrics for
precision and accuracy. Additionally, we use participant feedback to
identify future avenues for improvement of MergeBERT.",
}
@article{10.1145/3688155,
author = {Lahiri, Shuvendu and Svyatkovskiy, Alexey and Bird, Christian and Meijer, Erik and Coatta, Terry},
title = {Program Merge: What's Deep Learning Got to Do with It? A discussion with Shuvendu Lahiri, Alexey Svyatkovskiy, Christian Bird, Erik Meijer and Terry Coatta},
year = {2024},
issue_date = {July/August 2024},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
volume = {22},
number = {4},
issn = {1542-7730},
url = {https://doi.org/10.1145/3688155},
doi = {10.1145/3688155},
abstract = {If you regularly work with open-source code or produce software for a large organization, you're already familiar with many of the challenges posed by collaborative programming at scale. Some of the most vexing of these tend to surface as a consequence of the many independent alterations inevitably made to code, which, unsurprisingly, can lead to updates that don't synchronize. Difficult merges are nothing new, of course, but the scale of the problem has gotten much worse. This is what led a group of researchers at MSR (Microsoft Research) to take on the task of complicated merges as a grand program-repair challenge, one they believed might be addressed at least in part by machine learning.},
journal = {Queue},
month = sep,
pages = {101–119},
numpages = {19}
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Merging -- other representations
%%%
@article{10.1145/3276535,
author = {Sousa, Marcelo and Dillig, Isil and Lahiri, Shuvendu K.},
title = {Verified Three-Way Program Merge},
year = {2018},
issue_date = {November 2018},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
volume = {2},
number = {OOPSLA},
url = {https://doi.org/10.1145/3276535},
doi = {10.1145/3276535},
abstract = {Even though many programmers rely on 3-way merge tools to integrate changes from different branches, such tools can introduce subtle bugs in the integration process. This paper aims to mitigate this problem by defining a semantic notion of conflict-freedom, which ensures that the merged program does not introduce new unwanted behaviors. We also show how to verify this property using a novel, compositional algorithm that combines lightweight summarization for shared program fragments with precise relational reasoning for the modifications. Towards this goal, our method uses a 4-way differencing algorithm on abstract syntax trees to represent different program versions as edits applied to a shared program with holes. This representation allows our verification algorithm to reason about different edits in isolation and compose them to obtain an overall proof of conflict freedom. We have implemented the proposed technique in a new tool called SafeMerge for Java and evaluate it on 52 real-world merge scenarios obtained from GitHub. The experimental results demonstrate the benefits of our approach over syntactic conflict-freedom and indicate that SafeMerge is both precise and practical.},
journal = {Proc. ACM Program. Lang.},
month = {oct},
articleno = {165},
numpages = {29},
keywords = {Three-way program merge, product programs, relational verification}
}
@Article{Berzins1994,
author = "Berzins, Valdis",
title = "Software Merge: Semantics of Combining Changes to Programs",
journal = TOPLAS,
year = 1994,
volume = 16,
number = 6,
pages = "1875-1903",
note = nov,
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% New version control systems
%%%
@inproceedings{10.1145/2905055.2905072,
author = {Rao, N. Rama and Sekharaiah, K. Chandra},
title = {A Methodological Review Based Version Control System with Evolutionary Research for Software Processes},
year = {2016},
isbn = {9781450339629},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/2905055.2905072},
doi = {10.1145/2905055.2905072},
abstract = {The constant add up of new features and bug fixes often make invariable changes and refinements inevitable in the software development at regular intervals. The software should enable the end-user to decipher the critical version information about the minutest detail in every software artifact and if it does not, no software can be called as complete or nor is it user-friendly. When developers check in the software files they have to put in the version field manually as a part of header information inside the file. It would be difficult to identify vulnerabilities in the software when the files lack embedded version information which makes it harder for the end users to accurately identify the running version of the software. How can version control system (VCS) help in optimizing the bug traceability time and bug fixing potential? Version control system (VCS) is a software application that helps in collaborative software development of software projects. In order to support this instance, we should analyze which version control system is to be considered and whether to use central repository version control system or local repository version control system. Various functional, non functional evaluation criteria and fundamental requirements like installation, configuration, learning curve, performance, commits, branching, merging, and tagging have been considered for a through comparison of many version control systems. In this paper, we review and analyze the currently used VCS that involved in a view of a collaborative software development for software evolution. And an attempt has also been made to identify the version information in every deliverable file or retain it with the source. We demonstrate and perform survey on current versioning systems like Concurrent Version Control System (CVS), Subversion (SVN), Team Foundation Server (TFS), Git, ACME, Visual Source Safe(VSS), Mercurial and Clear Case, etc. that offers opportunities to test produced results and validate.},
booktitle = {Proceedings of the Second International Conference on Information and Communication Technology for Competitive Strategies},
articleno = {14},
numpages = {6},
keywords = {Source code management(SCM), CVS, Git, SVN, Mercurial, Distributed version control system(DVCS), TFS, Version control system(VCS)},
location = {Udaipur, India},
series = {ICTCS '16}
}
@InProceedings{CavalcantiBSA2019,
author = "Guilherme Cavalcanti and Paulo Borba and Georg Seibt and Sven Apel",
title = "The impact of structure on software merging: Semistructured versus structured merge",
crossref = "ASE2019",
pages = "1002-1013",
abstract =
"Merge conflicts often occur when developers concurrently change
the same code artifacts. While state of practice unstructured merge tools
(e.g Git merge) try to automatically resolve merge conflicts based on textual
similarity, semistructured and structured merge tools try to go further by
exploiting the syntactic structure and semantics of the artifacts
involved. Although there is evidence that semistructured merge has
significant advantages over unstructured merge, and that structured merge
reports significantly fewer conflicts than unstructured merge, it is unknown
how semistructured merge compares with structured merge. To help developers
decide which kind of tool to use, we compare semistructured and structured
merge in an empirical study by reproducing more than 40,000 merge scenarios
from more than 500 projects. In particular, we assess how often the two merge
strategies report different results, we identify conflicts incorrectly
reported by one but not by the other (false positives), and conflicts
correctly reported by one but missed by the other (false negatives). Our
results show that semistructured and structured merge differ in 24% of the
scenarios with conflicts. Semistructured merge reports more false positives,
whereas structured merge has more false negatives. Finally, we found that
adapting a semistructured merge tool to resolve a particular kind of conflict
makes semistructured and structured merge even closer.",
}
@inproceedings{10.1145/3135932.3135943,
author = {Cavalcanti, Guilherme},
title = {What Merge Tool Should I Use?},
year = {2017},
isbn = {9781450355148},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3135932.3135943},
doi = {10.1145/3135932.3135943},
abstract = {While unstructured merge tools try to automatically resolve merge conflicts via textual similarity, semistructured and structured merge tools try to go further by exploiting the syntactic structure and semantics of the involved artefacts. Previous studies compare these merge approaches with respect to the number of reported conflicts, showing, for most projects and merge situations, a reduction in favor of semistructured and structured merge. However, these studies do not investigate whether this reduction actually leads to integration effort reduction (Productivity) without negative impact on the correctness of the merging process (Quality). To analyze this, and to better understand how these tools could be improved, we propose empirical studies to identify spurious conflicts (false positives) reported by one approach but not by the other, and interference reported as conflict by one approach but missed by the other (false negatives).},
booktitle = {Proceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity},
pages = {19-20},
numpages = {2},
keywords = {version control systems, empirical studies, software merging, collaborative development},
location = {Vancouver, BC, Canada},
series = {SPLASH Companion 2017}
}
@InProceedings{TavaresBCS2020,
author = "Tavares, Alberto Trindade and Borba, Paulo and Cavalcanti, Guilherme and Soares, S\'{e}rgio",
title = "Semistructured Merge in {JavaScript} Systems",
crossref = "ASE2020",
pages = "1014-1025",
abstract = {Industry widely uses unstructured merge tools that rely on textual analysis to detect and resolve conflicts between code contributions. Semistructured merge tools go further by partially exploring the syntactic structure of code artifacts, and, as a consequence, obtaining significant merge accuracy gains for Java-like languages. To understand whether semistructured merge and the observed gains generalize to other kinds of languages, we implement two semistructured merge tools for JavaScript, and compare them to an unstructured tool. We find that current semistructured merge algorithms and frameworks are not directly applicable for scripting languages like JavaScript. By adapting the algorithms, and studying 10,345 merge scenarios from 50 JavaScript projects on GitHub, we find evidence that our JavaScript tools report fewer spurious conflicts than unstructured merge, without compromising the correctness of the merging process. The gains, however, are much smaller than the ones observed for Java-like languages, suggesting that semistructured merge advantages might be limited for languages that allow both commutative and non-commutative declarations at the same syntactic level.},
}
@inproceedings{10.1145/3555228.3555229,
author = {Campos Junior, Heleno de S. and de Menezes, Gleiph Ghiotto L. and Barros, M\'{a}rcio de Oliveira and van der Hoek, Andr\'{e} and Murta, Leonardo Gresta Paulino},
title = {Towards Merge Conflict Resolution by Combining Existing Lines of Code},
year = {2022},
isbn = {9781450397353},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3555228.3555229},
doi = {10.1145/3555228.3555229},
abstract = {Software developers often need to combine their contributions. This operation is called merge. When the contributions happen at the same physical region in the source code, the merge is marked as conflicting and must be manually resolved by the developers. Existing studies explore why conflicts happen, their characteristics, and how they are resolved. In this paper, we investigate a specific subset of merge conflicts, which may be resolved using a combination of existing lines. We analyze 10,177 conflict chunks of popular projects that were resolved by combining existing lines, aiming at characterizing and finding patterns that developers frequently use to resolve them. We found that these conflicting chunks and their resolutions are usually small (they have a median of 6 LOC and 3 LOC, respectively). Moreover, 98.6\% of the analyzed resolutions preserve the order of the lines in the conflicting chunks. We also found that 77.4\% of the chunk resolutions do not interleave lines from different contributions more than once. These findings altogether, when used as heuristics for automatic merge resolution, could enable the reduction of the search space by 94.7\%, paving the road for future search-based software engineering tools for this problem.},
booktitle = {Proceedings of the XXXVI Brazilian Symposium on Software Engineering},
pages = {425-434},
numpages = {10},
keywords = {search-based software engineering, conflict resolution, Version control systems, software merge},
location = {Virtual Event, Brazil},
series = {SBES '22}
}
@inproceedings{10.1109/ICSE-C.2017.103,
author = {Cavalcanti, Guilherme and Borba, Paulo and Accioly, Paola},
title = {Should We Replace Our Merge Tools?},
year = {2017},
isbn = {9781538615898},
publisher = {IEEE Press},
url = {https://doi.org/10.1109/ICSE-C.2017.103},
doi = {10.1109/ICSE-C.2017.103},
abstract = {While unstructured merge tools try to automatically resolve merge conflicts via textual similarity, semistructured merge tools try to go further by partially exploiting the syntactic structure and semantics of the involved artefacts. Previous studies compare these merge approaches with respect to the number of reported conflicts, showing, for most projects and merge situations, a reduction in favor of semistructured merge. However, these studies do not investigate whether this reduction actually leads to integration effort reduction (Productivity) without negative impact on the correctness of the merging process (Quality). To analyze this, and to better understand how these tools could be improved, we propose empirical studies to identify spurious conflicts reported by one approach but not by the other, and interference reported as conflict by one approach but missed by the other.},
booktitle = {Proceedings of the 39th International Conference on Software Engineering Companion},
pages = {325-327},
numpages = {3},
keywords = {empirical studies, version control systems, collaborative development, software merging},
location = {Buenos Aires, Argentina},
series = {ICSE-C '17}
}
@Article{ZhuH2018,
author = "Zhu, Fengmin and He, Fei",
title = "Conflict Resolution for Structured Merge via Version Space Algebra",
journal = PACMPL,
year = 2018,
volume = 2,
number = "OOPSLA",
month = oct,
articleno = 166,
numpages = 25,
abstract =
"Resolving conflicts is the main challenge for software merging. The
existing merge tools usually rely on the developer to manually resolve
conflicts. This is of course inefficient. We propose an interactive
approach for resolving merge conflicts. To the best of our knowledge, this
is the first attempt for conflict resolution of structured merge. To
represent the possibly very large set of candidate programs, we propose an
expressive and efficient representation by version space algebra. We also
design a simple mechanism for ranking resolutions in the program space,