Git Best Practices: Managing Merge Conflicts

In the world of software development, especially when working with Git and other version control systems, merge conflicts are a common occurrence. They happen when two or more developers make changes to the same part of a file or when simultaneous updates across branches are conflicting. While Git is usually smart enough to merge changes automatically, some situations arise where human intervention is needed to resolve these conflicts.

What Are Merge Conflicts?

A merge conflict occurs when Git cannot automatically merge the changes from different branches. Git handles most merges by using a three-way merge algorithm, comparing the last common ancestor of the branches, the changes on one branch, and the changes on the other.

However, when Git encounters conflicting changes in the same part of a file, it stops the process and flags it as a conflict. This requires manual intervention to decide which changes to keep.

Types of Merge Conflicts

• Content conflicts: Occurs when two branches modify the same section of code in different ways.
• Deletion conflicts: Happens when one branch deletes a file while another branch modifies the same file.
• File-level conflicts: Occur when two branches create files with the same name but different contents.

How Do Merge Conflicts Occur?

Merge conflicts generally occur when two developers (or two branches) are working on the same file and make incompatible changes. Consider a team of developers working on a project, each on their respective branch. When these changes are brought together (via merging or rebasing), Git tries to combine them, but if it encounters changes that contradict each other, it can’t merge them automatically.

Let’s take an example to understand this better:

Example Scenario:

1. Developer A makes a change in txt and pushes it to a branch called feature-branch.
2. Developer B also makes a change to the same txt but in a different way and pushes it to the main branch.
3. Now, when Developer A tries to merge feature-branch into main, a merge conflict arises because Git doesn’t know which change to keep.

Git detects this conflict and halts the process until a resolution is provided.

How to Resolve Merge Conflicts?

Step 1: Identifying the Conflict

When you attempt to merge two branches and a conflict arises, Git provides you with a message indicating the files with conflicts. For example:

The file with the conflict will show special markers to indicate the conflicting changes:

The content between <<<<<<< HEAD and ======= shows what’s in your current branch (main).

The content between ======= and >>>>>>> feature-branch shows what’s in the branch you are trying to merge (feature-branch).

Step 2: Manually Resolving the Conflict

You must now manually edit the file to resolve the conflict. You can choose to:

• Keep Developer A’s changes
• Keep Developer B’s changes
• Combine both changes

For example, if both changes are relevant, you might edit the file to combine the best of both:

After resolving the conflict, save the file.

Step 3: Marking Conflict as Resolved

Once the conflicts are resolved in the files, you need to mark them as resolved using:

Finally, complete the merge by committing:

The conflict is now resolved, and your branches have been successfully merged.

Examples of Merge Conflicts and Resolution Techniques

Example 1: Content Conflict

Let’s say we have two branches, main and feature-branch, and the file file.txt exists in both branches.

• In the main branch:

• In the feature-branch:

When you try to merge feature-branch into main, Git will identify the conflict because both branches modified the same line.

Resolution:

• Edit file.txt to decide how to merge the changes. You can choose either:

or

Or even combine them:

After resolving, save, and commit the changes.

Example 2: Deletion Conflict

Consider two branches: main and cleanup-branch. The cleanup-branch deletes a file called old_code.js, while the main branch modifies this file.

• In the main branch:

• In the cleanup-branch:

When you merge cleanup-branch into main, Git will flag this as a conflict because one branch modified the file while the other deleted it.

Resolution:

You need to decide whether to keep the changes from the main branch (and not delete the file) or proceed with the deletion from cleanup-branch.

• If you want to keep the deletion, you can remove the file:

• Then commit the change:

Best Practices to Avoid Merge Conflicts

Merge conflicts can disrupt workflows and cause delays. While they’re not always avoidable, here are some practices to reduce the frequency of conflicts:

1. Pull Changes Frequently

• To minimize conflicts, it’s a good practice to pull updates from the shared branch (e.g., main) regularly, especially before making new changes or committing.

• This ensures that your local branch is up to date with the latest changes and reduces the likelihood of conflicting changes.

2. Work in Small, Focused Commits

When possible, make small, incremental changes rather than large, sweeping ones. Smaller changes are easier to review, less likely to conflict with others, and easier to resolve if conflicts do occur.

3. Communicate with Your Team

Clear communication among team members can help avoid conflicts. Make sure everyone is aware of which files or areas of code they are working on, so there’s less overlap in modifications.

4. Rebase Instead of Merging (when appropriate)

In some workflows, it might be better to rebase instead of merging, especially when working on feature branches. Rebasing helps you keep a cleaner commit history and reduces the chances of conflicts, though it’s not always the best solution for all teams.

5. Use Feature Flags

In larger teams, using feature flags can help isolate features in development, allowing developers to merge their code without fully integrating incomplete features. This reduces the risk of conflicts.

Conclusion

Merge conflicts are an inevitable part of working in collaborative software development environments, especially with Git. Understanding what merge conflicts are, how they occur, and how to resolve them is crucial to maintaining a smooth workflow. By following best practices and learning how to quickly identify and resolve conflicts, developers can minimize disruptions and keep the development process moving forward.

Ultimately, mastering conflict resolution in Git is an essential skill for any developer working in a team-based environment. By adopting proactive strategies like frequent communication, small commits, and frequent pulls, teams can work harmoniously, reducing the chances of major disruptions caused by merge conflicts.

About CloudThat

CloudThat is a leading provider of Cloud Training and Consulting services with a global presence in India, the USA, Asia, Europe, and Africa. Specializing in AWS, Microsoft Azure, GCP, VMware, Databricks, and more, the company serves mid-market and enterprise clients, offering comprehensive expertise in Cloud Migration, Data Platforms, DevOps, IoT, AI/ML, and more.

CloudThat is the first Indian Company to win the prestigious Microsoft Partner 2024 Award and is recognized as a top-tier partner with AWS and Microsoft, including the prestigious ‘Think Big’ partner award from AWS and the Microsoft Superstars FY 2023 award in Asia & India. Having trained 650k+ professionals in 500+ cloud certifications and completed 300+ consulting projects globally, CloudThat is an official AWS Advanced Consulting Partner, Microsoft Gold Partner, AWS Training Partner, AWS Migration Partner, AWS Data and Analytics Partner, AWS DevOps Competency Partner, AWS GenAI Competency Partner, Amazon QuickSight Service Delivery Partner, Amazon EKS Service Delivery Partner,  AWS Microsoft Workload Partners, Amazon EC2 Service Delivery Partner, Amazon ECS Service Delivery Partner, AWS Glue Service Delivery Partner, Amazon Redshift Service Delivery Partner, AWS Control Tower Service Delivery Partner, AWS WAF Service Delivery Partner and many more.

To get started, go through our Consultancy page and Managed Services Package, CloudThat’s offerings.