Git - Handling Conflicts

Hello, aspiring coders! Today, we're diving into one of the most important skills in collaborative programming: handling conflicts in Git. As your friendly neighborhood computer science teacher, I'm here to guide you through this sometimes tricky but always important topic. Let's get started!

Understanding Git Conflicts

Before we jump into the nitty-gritty, let's talk about what a conflict is. Imagine you and your friend are both painting the same wall. You decide to paint it blue, while your friend paints it red. When you meet up, you realize you've got a problem - that's essentially what a Git conflict is in the world of coding.

In Git terms, a conflict occurs when two branches have made edits to the same line in a file, or when a file has been deleted in one branch but edited in the other. Git can't automatically determine which change should take precedence.

Perform Changes in wchar_support Branch

Let's start with a practical example. We'll create a new branch called wchar_support and make some changes there.

git checkout -b wchar_support

This command creates a new branch and switches to it. Now, let's edit a file called hello.c:

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

We'll modify this to support wide characters:

#include <wchar.h>

int main() {
    wprintf(L"Hello, Wide World!\n");
    return 0;
}

Now, let's commit these changes:

git add hello.c
git commit -m "Add wide character support"

Great! We've made our changes in the wchar_support branch.

Perform Changes in Master Branch

Now, let's switch back to the master branch and make a different change to the same file:

git checkout master

Edit hello.c again:

#include <stdio.h>

int main() {
    printf("Hello, Beautiful World!\n");
    return 0;
}

And commit these changes:

git add hello.c
git commit -m "Update greeting message"

Tackle Conflicts

Now comes the exciting part! Let's try to merge our wchar_support branch into master:

git merge wchar_support

Uh oh! Git will likely give you a message like this:

Auto-merging hello.c
CONFLICT (content): Merge conflict in hello.c
Automatic merge failed; fix conflicts and then commit the result.

Don't panic! This is normal. Git is simply telling us that it can't automatically merge the changes because both branches modified the same part of the file.

Resolve Conflicts

Now it's time to roll up our sleeves and resolve this conflict manually. If you open hello.c, you'll see something like this:

<<<<<<< HEAD
#include <stdio.h>

int main() {
    printf("Hello, Beautiful World!\n");
=======
#include <wchar.h>

int main() {
    wprintf(L"Hello, Wide World!\n");
>>>>>>> wchar_support
    return 0;
}

Let's break this down:

• Everything between <<<<<<< HEAD and ======= is from our current branch (master).
• Everything between ======= and >>>>>>> wchar_support is from the branch we're trying to merge.

To resolve the conflict, we need to decide which changes to keep. We might decide we want both the wide character support and the new message. So, we could edit the file to look like this:

#include <wchar.h>

int main() {
    wprintf(L"Hello, Beautiful Wide World!\n");
    return 0;
}

After editing, we need to stage the file and commit:

git add hello.c
git commit -m "Merge wchar_support, keeping both wide char support and new message"

Congratulations! You've just resolved your first Git conflict.

Common Methods for Resolving Conflicts

Here's a handy table of common methods for resolving conflicts:

Method	Description
Keep Current	Choose the changes from the current (master) branch
Keep Incoming	Choose the changes from the incoming (wchar_support) branch
Keep Both	Incorporate changes from both branches
Manual Edit	Carefully edit the file to combine changes as needed

Remember, the best method depends on your specific situation and project needs.

Conclusion

Handling conflicts in Git might seem daunting at first, but with practice, it becomes second nature. It's a crucial skill in collaborative coding, allowing multiple developers to work on the same project without stepping on each other's toes (too much).

In my years of teaching, I've seen students go from dreading conflicts to embracing them as opportunities to review and improve code. So don't worry if it feels challenging at first - you're on the right path!

Next time you encounter a Git conflict, take a deep breath, grab your favorite beverage, and remember: you're not just resolving a conflict, you're weaving together the creative efforts of your team. Happy coding!

Credits: Image by storyset