Introduction

Myers and Hunt–McIlroy are two important names in text differencing, but they are easiest to compare when you separate the core algorithm from the surrounding heuristics that make a diff readable. Both aim to transform one sequence into another, yet they emphasize different tradeoffs in how matches are found and how practical tools behave on real files. For source control and code review, those tradeoffs matter as much as the raw edit distance.

A Diff Engine Balances More Than Correctness

A real diff tool is not optimizing only one number. It usually needs to balance:

• correctness of the transformation,
• readability of the resulting hunks,
• and speed and memory behavior on practical input sizes.

The mathematically shortest edit script is not always the easiest diff for a human to review. That is why production diff tools combine a core algorithm with output heuristics and formatting decisions.

Myers Focuses on the Shortest Edit Script

Myers’ algorithm is widely known for efficiently computing a shortest edit script using an edit-graph viewpoint. In practice, it performs very well for many source-code workloads and is a common choice in modern version-control tooling.

A small edit-distance illustration captures the idea of furthest-reaching paths by edit distance.

1def myers_edit_distance(a, b):
2    n, m = len(a), len(b)
3    max_d = n + m
4    v = {1: 0}
5
6    for d in range(max_d + 1):
7        for k in range(-d, d + 1, 2):
8            if k == -d or (k != d and v.get(k - 1, 0) < v.get(k + 1, 0)):
9                x = v.get(k + 1, 0)
10            else:
11                x = v.get(k - 1, 0) + 1
12
13            y = x - k
14            while x < n and y < m and a[x] == b[y]:
15                x += 1
16                y += 1
17
18            v[k] = x
19            if x >= n and y >= m:
20                return d
21
22    return max_d
23
24print(myers_edit_distance("kitten", "sitting"))

Production diff tools do more than this, but the example shows why Myers is associated with concise edit scripts.

Hunt–McIlroy Comes from a More Heuristic Line-Matching Tradition

Hunt–McIlroy is strongly associated with early Unix diff behavior and line-oriented matching heuristics. It is historically important because it shaped how people expect text diffing tools to behave, especially for line-based source files.

A simple longest-common-subsequence baseline illustrates part of the conceptual family.

1def lcs_length(a, b):
2    n, m = len(a), len(b)
3    dp = [[0] * (m + 1) for _ in range(n + 1)]
4
5    for i in range(1, n + 1):
6        for j in range(1, m + 1):
7            if a[i - 1] == b[j - 1]:
8                dp[i][j] = dp[i - 1][j - 1] + 1
9            else:
10                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
11
12    return dp[n][m]
13
14print(lcs_length(list("ABCBDAB"), list("BDCABA")))

Pure dynamic-programming LCS is not how large production diffs are usually implemented, but it helps explain why Hunt–McIlroy-style approaches are often discussed in terms of line matching and common subsequence structure.

The Practical Difference Is Often in Behavior on Real Text

For many code-review and version-control workloads, Myers-style algorithms are favored because they often deliver concise changes efficiently. Hunt–McIlroy-style behavior remains valuable where traditional line-oriented diff expectations and heuristics are important.

The important nuance is that user-visible diff quality depends heavily on hunk formatting and match heuristics layered on top of the core algorithm. So comparing tools by algorithm name alone is often incomplete.

Repetitive Files Stress Diff Algorithms Differently

Highly repetitive files create ambiguity in what should match what. Generated files, minified content, or repeated boilerplate can change the readability of a diff more than the theoretical optimality of the core algorithm.

That is why benchmarking on tiny textbook examples is not enough. The corpus shape matters.

Human Readability Can Beat Mathematical Minimality

A shortest edit script is mathematically appealing, but reviewers do not read edit graphs. They read hunks. If a slightly different grouping makes the change easier to understand, many tools will prefer readability over perfect minimality.

So the better evaluation questions are often:

• does the diff help humans review the change,
• how does it behave on the project’s real files,
• and how much memory and time does it consume under that workload.

Common Pitfalls

• Comparing algorithms only on toy inputs and assuming the result generalizes.
• Equating shortest edit script with best human-readable diff in every case.
• Ignoring memory behavior while focusing only on CPU time.
• Treating diff-tool behavior as if it came only from the core algorithm rather than heuristics around it.
• Choosing an algorithm by historical familiarity instead of workload fit.

Summary

• Myers and Hunt–McIlroy are both important approaches to sequence differencing.
• Myers is widely associated with efficient shortest-edit-script behavior.
• Hunt–McIlroy is historically important for line-oriented diff behavior and heuristics.
• Practical diff quality depends on heuristics and formatting as well as the core algorithm.
• Choose based on corpus shape, readability goals, and implementation constraints, not only on algorithm name.