What is `git diff --patience` for?

Question

How does the patience algorithm differ from the default git diff algorithm, and when would I want to use it?

Maybe it matches moved code and modified lines which can be much slower — codymanix, Oct 28 '10 at 16:32
I've extracted a standalone script for Patience Diff from Bazaar, you can find it in [another SO thread](http://stackoverflow.com/questions/4599456/textually-diffing-json/4599500#4599500). — TryPyPy, Jan 05 '11 at 00:48
There is also the `--histogram` parameter which "...extends the patience algorithm to "support low-occurrence common elements" http://git-scm.com/docs/git-diff.html — Robert, May 23 '14 at 12:33

score 189 · Accepted Answer · edited Jun 20 '20 at 09:12

189

You can read a post from Bram Cohen, the author of the patience diff algorithm, but I found this blog post to summarize the patience diff algorithm very well:

Patience Diff, instead, focuses its energy on the low-frequency high-content lines which serve as markers or signatures of important content in the text. It is still an LCS-based diff at its core, but with an important difference, as it only considers the longest common subsequence of the signature lines:

Find all lines which occur exactly once on both sides, then do longest common subsequence on those lines, matching them up.

When should you use patience diff? According to Bram, patience diff is good for this situation:

The really bad cases are ones where two versions have diverged dramatically and the developer isn't being careful to keep patch sizes under control. Under those circumstances a diff algorithm can occasionally become 'misaligned' in that it matches long sections of curly brackets together, but it winds up correlating the curly brackets of functions in one version with the curly brackets of the next later function in the other version. This situation is very ugly, and can result in a totally unusable conflict file in the situation where you need such things to be presented coherently the most.

edited Jun 20 '20 at 09:12

Community

1
1

answered Oct 28 '10 at 16:34

Mark Rushakoff

224,642
43
388
389

3

In my experience with XML for now, it gives exactly the same "bad" results as a normal diff. – stivlo Jun 23 '11 at 14:25
5

I've had much better luck with patience diff with XML; certainly the diff I'm looking at currently has exactly the misalignment problem described with the regular diff algorithm, but looks absolutely grand with patience diff. – me_and Sep 14 '12 at 13:10
22

This blog has a great explaination, including an animated gif of the process: http://alfedenzo.livejournal.com/170301.html – Quantum7 Jun 18 '13 at 23:38
3

I've found this blog very interesting and providing good explanation with further links to algorithms details: http://fabiensanglard.net/git_code_review/diff.php Hope it will be useful to someone – SathOkh Jun 24 '14 at 20:25
The frobnitz/fib/fact diff can be seen at https://gist.github.com/roryokane/6f9061d3a60c1ba41237 – George V. Reilly Dec 27 '17 at 05:47

score 54 · Answer 2 · answered Dec 29 '11 at 12:46

54

You can also use it for merges (worked really well here for some XML conflicts):

git merge --strategy-option=patience ...

answered Dec 29 '11 at 12:46

robinst

26,202
9
95
101

53

Or via `git config --global diff.algorithm patience` – Tobu Apr 11 '13 at 07:50
11

Shorter would be `git merge -X patience`. – PythonNut Jul 15 '15 at 21:34

Wilfred Hughes · Answer 3 · 2017-08-24T13:39:35.433

The patience diff algorithm is a slower diff algorithm that shows better results in some cases.

Suppose you have the following file checked in to git:

.foo1 {
    margin: 0;
}

.bar {
    margin: 0;
}

Now we reorder the sections and add a new line:

.bar {
    margin: 0;
}

.foo1 {
    margin: 0;
    color: green;
}

The default diff algorithm claims that the section headings have changed:

$ git diff --diff-algorithm=myers   
diff --git a/example.css b/example.css
index 7f1bd1e..6a64c6f 100755
--- a/example.css
+++ b/example.css
@@ -1,7 +1,8 @@
-.foo1 {
+.bar {
     margin: 0;
 }

-.bar {
+.foo1 {
     margin: 0;
+    color: green;
 }

Whereas patience diff shows a result that is arguably more intuitive:

$ git diff --diff-algorithm=patience
diff --git a/example.css b/example.css
index 7f1bd1e..6a64c6f 100755
--- a/example.css
+++ b/example.css
@@ -1,7 +1,8 @@
-.foo1 {
-    margin: 0;
-}
-
 .bar {
     margin: 0;
 }
+
+.foo1 {
+    margin: 0;
+    color: green;
+}

There's a good discussion of subjective diff quality here, and git 2.11 is exploring diff heuristics further.

Note that the patience diff algorithm still has some known pathological cases.

What is `git diff --patience` for?

3 Answers3

Linked