Understanding Git Merge and Handling Conflicts

In this post, you'll learn about Git merge, which is one of the most important and commonly used operations in Git repositories. Merging is the process of combining changes from one branch into another, typically used in parallel development workflows. This allows developers to work on features independently in separate branches and eventually integrate them into the main branch (e.g., master or main)."

Two Types of Git Merge Scenarios

When working with Git, merging can occur in two primary scenarios based on the state of the branches being merged:

1. Fast-Forward Merge

A fast-forward merge happens when no new commits have been added to the target branch (e.g., master) since the feature branch was created. This makes the master branch "move forward" to point to the latest commit in the feature branch.

Scenario:

1. You start with the master branch at commit C2M.

2. You create a feature branch at C2M.

3. You make multiple commits in the feature branch (C1F, C2F ).

4. In the meantime, no new commits happen in the master branch.

When you merge the feature branch back into master, Git simply moves the HEAD of the master branch forward to point to the latest commit of the feature branch.

Characteristics:

• There is no new merge commit.

• The commit history remains linear.

• There are no conflicts because no changes occurred in the master branch after branching.

Step-by-Step Scenario with Example:

Here’s an example workflow to demonstrate how a Fast-Forward Merge works:

1. Start with the Master Branch:

You are currently on the master branch with the two commits C1M, C2M

2. Create a new feature branch using:

After creating a new branch it inherited files from the master. Now, the feature branch has commits C1M and C2M.

3. Make Changes( Add files) and make commits on the feature branch:

Your commit history on the feature branch now looks like this:

4. Switch Back to Master:

We can see only two commits in the master

5. Merge the Feature Branch into Master:

Since no changes were made on master during the time I worked on the feature, Git performs a Fast-Forward Merge:

Now we can see four commits in the master after a successful Fast-forward merge.

Key Characteristics of Fast-Forward Merge:

• No Merge Commit: Git does not create an extra merge commit.

• Linear Commit History: The commit history remains clean and sequential.

• No Conflicts: Since there were no changes in the target branch (master), conflicts do not arise.

________________________________________

2. Three-Way Merge

A three-way merge occurs when changes have been made in both the master branch and the feature branch after the feature branch was created. Git will create a new merge commit to combine these changes.

Scenario:

1. You start with the master branch at commit C2M.

2. You create a feature branch at C2M.

3. New commits happen in the master branch (C3M).

4. Simultaneously, commits happen in the feature branch (C1F).

When you merge the feature branch into the master branch, Git needs to:

• Compare the common ancestor commit (C2M),

• Compare the changes in the master branch (C3M), and

• Compare the changes in the feature branch (C1F).

Step-by-Step Scenario with Example:

Here’s an example workflow to demonstrate how a Three-Way Merge works:

1. Start with the Master Branch:

Master branch two commits C1M,C2M

2. Create a Feature Branch:

Create and switch to the feature branch from the latest commit on master

3. Make Changes on the Feature Branch:

Add changes and commit.

4. Now the feature branch has an additional commit.

5. Switch Back to Master and Make Changes:

Now C3M commit is the change in master.

6. Merge Feature Branch into Master:

At this point, Git detects changes in the same file (TestFile.txt) on both branches, causing a merge conflict.

7. After resolving the conflict in the file, stage and commit the merge:

8. Final Commit History:

After resolving the conflict, the commit history looks like this:

Characteristics:

• A new merge commit is created to combine changes.

• The commit history will show the branches diverging and merging.

• Conflicts may arise if changes overlap, and need to be resolved manually.

Following this workflow, you can successfully perform a Three-Way Merge in Git and resolve conflicts to integrate parallel changes into your main branch.

___________________________________________________________________________________________________

Aspect	Fast-Forward Merge	Three-Way Merge
Branch Changes	No changes in the target branch.	Changes exist in both branches.
Merge Commit	No merge commit is created.	A new merge commit is created.
History	Linear commit history.	Commit history shows branch divergence.

Conclusion

By understanding both types of merging, you can choose the approach that best fits your workflow:

• Fast-forward merges are ideal for maintaining a clean and linear history when there are no parallel changes.

• Three-way merges are necessary when combining parallel developments, ensuring all changes are preserved, even when conflicts arise.

This should help you not only understand how Git merge works but also choose the appropriate merging strategy for your project.