Highlights from Git 2.36

[1] http://kdiff3.sourceforge.net/

https://github.com/dandavison/delta

When I'm merging, and things are really messed up due to unrelated things being diffed together, in a situation in which both must survive in the merged result, I do this:

1. Find syntactic boundaries before and after the conflict, in order to delimit an area that is a complete piece of top-level syntax, in which the conflict lies. So that is to say if the conflict is flanked by fragments of syntax, I include them.

2. I make a copy of this entire area, so that I have two consecutive copies of the complete syntactic unit, and therefore two copies of the conflict.

3. Go through the first copy and edit it with a view toward one side of the conflict.

4. Repeat on the second copy, but with a view toward keeping the changes from the other side of the conflict.

Example (manually created):

   static void foo(int x)
   {
   <<<<<<<
     return x;
   }

   static void bar(int y)
   {
      return y;
   =======
      return x + 1;
   }

   static void xyzzy(int z)
   {
     return z
   >>>>>>>
   }

OK, what is the complete syntactic unit? We include everything from the "static void foo" to the closing brace after the >>>>>> and copy it. We include markers:

   // COPY A
   static void foo(int x)
   {
   <<<<<<<
     return x;
   }

   static void bar(int y)
   {
      return y;
   =======
      return x + 1;
   }

   static void xyzzy(int z)
   {
     return z
   >>>>>>>
   }

   // COPY B
   static void foo(int x)
   {
   <<<<<<<
     return x;
   }

   static void bar(int y)
   {
      return y;
   =======
      return x;
   }

   static void xyzzy(int z)
   {
     return z
   >>>>>>>
   }

   // COPY A
   static void foo(int x)
   {
     return x;
   }

   static void bar(int y)
   {
      return y;
   }

   // COPY B
   static void foo(int x)
   {
   <<<<<<<
     return x + 1;
   }

   static void bar(int y)
   {
      return y;
   =======
      return x;
   }

   static void xyzzy(int z)
   {
     return z
   >>>>>>>
   }

   // COPY A
   static void foo(int x)
   {
     return x;
   }

   static void bar(int y)
   {
      return y;
   }

   // COPY B
   static void foo(int x)
   {
      return x + 1;
   }

   static void xyzzy(int z)
   {
     return z
   }

   static void foo(int x)
   {
     return x + 1;
   }

   static void bar(int y)
   {
      return y;
   }

   static void xyzzy(int z)
   {
     return z
   }

Manually reading through merge conflict markers feels very old once you get used to this.

I know folks like MS have made big changes to the underlying storage layers to better handle massive repos.

https://mirrors.edge.kernel.org/pub/software/scm/git/