how Git detect changes

EL HADDAD Mohamed — Mon, 17 Aug 2026 07:03:46 +0000

Have you ever wondered why 𝑮𝒊𝒕 is so smart at detecting changes, even with the smallest tweaks or when you move an entire block of code around?

The secret is the 𝑴𝒚𝒆𝒓𝒔 𝑫𝒊𝒇𝒇 𝑨𝒍𝒈𝒐𝒓𝒊𝒕𝒉𝒎, which solved the 𝐍𝐨𝐢𝐬𝐲 𝐃𝐢𝐟𝐟 problem found in older methods. Simple algorithms often see a code refactor as a total "delete and replace" resulting in a messy diff that's almost impossible to read.

The core of Myers' intelligence is the 𝐋𝐨𝐧𝐠𝐞𝐬𝐭 𝐂𝐨𝐦𝐦𝐨𝐧 𝐒𝐮𝐛𝐬𝐞𝐪𝐮𝐞𝐧𝐜𝐞 (LCS). Basically, the algorithm hunts for the longest "thread" of code that remained unchanged between the old and new versions. It then builds the diff around that thread to give you the Shortest Edit Script possible.
This approach is exactly why your git diff stays logical and clean, making 𝐏𝐮𝐥𝐥 𝐑𝐞𝐪𝐮𝐞𝐬𝐭𝐬 much easier to review regardless of how much refactoring you’ve done.

2 Tricky Java Quirks I Discovered While Preparing for the OCP Java SE 21 Exam

EL HADDAD Mohamed — Tue, 11 Aug 2026 20:29:35 +0000

While diving deep into my OCP Java SE 21 preparation, I stumbled upon two fascinating edge cases that are easy to miss during standard application development.

Here is what happened when I experimented with Records and the super keyword.

1-You Can't Name Record Components Anything You Want

In Java Records, the compiler automatically generates accessor methods using the exact name of each record component. I decided to test what happens if I name a component toString:

// ❌ Compilation Error!
public record User(String toString) {}

Why does this fail?
Java explicitly prohibits naming record components after zero-parameter methods in java.lang.Object (such as toString, hashCode, equals, getClass, clone, finalize, notify, notifyAll, wait).

Because a record component named toString would require generating an accessor method toString(), it creates a naming collision with the inherited Object.toString() method contract, triggering a compilation error immediately.

2. Why super.equals(this) is true

To test how Java handles instance references in memory, I ran this test inside a standard class:

public class ReferenceTest {
    public void evaluate() {
        System.out.println(super.equals(this)); // Output: true
    }

    public static void main(String[] args) {
        new ReferenceTest().evaluate();
    }
}

Why does it return true?
super is not a distinct object in memory. It is simply a keyword that refers to the current instance (this), while instructing the compiler to bypass overridden methods and use the superclass implementation instead.

When calling super.equals(this), it invokes Object.equals(Object obj). The default implementation in Object performs a reference check (this == obj). Since super and this point to the exact same object reference, the result evaluates to true.

DEV Community: EL HADDAD Mohamed

how Git detect changes

2 Tricky Java Quirks I Discovered While Preparing for the OCP Java SE 21 Exam