Branching and Merging in Git

1. What is a Branch?

Imagine your project's history is a single timeline of commits. A branch is like creating a new, parallel timeline that diverges from the main one. This allows you to work on new features or bug fixes in an isolated environment without affecting the stable, main version of your code.

The following video introduces this concept using a common real-world scenario: you're working on a feature when your manager asks you to fix an urgent bug.

Technically, a branch in Git is just a lightweight, movable pointer to a specific commit. When you create a new branch, you're creating a new pointer. Git also uses a special pointer called HEAD to keep track of which branch you are currently working on.

This approach is incredibly efficient because Git doesn't copy all your files for each new branch; it just creates a new pointer.

2. Creating, Listing, and Switching Branches

Now let's get practical. The main commands you'll use are:

• git branch <branch-name>: Creates a new branch.
• git branch: Lists all local branches and shows which one you're currently on (marked with an *).
• git checkout <branch-name>: Switches your working directory to the specified branch.
• git checkout -b <branch-name>: A convenient shortcut that creates a new branch and immediately switches to it.

The following video demonstrates how to use these commands.

Hands-on Practice: Branching in Action

Let's try this in our my-first-repo project.

1. Navigate to your repository directory in the terminal.
2. Ensure you're on the main branch (it might be called master or main). You can check with git branch.
3. Create and switch to a new branch for a new feature:
   git checkout -b feature/add-readme
4. List your branches to confirm you've switched:
   git branch
   You should see feature/add-readme with an asterisk next to it.
5. Now, create a new file and commit it on this branch:
   echo "# My First Repo" > README.md
git add README.md
git commit -m "feat: Add README file"
6. Switch back to your main branch:
   git checkout main (or master)
7. Look at your project folder or run ls. The README.md file is gone! This is because it only exists on the feature/add-readme branch. Your main branch is untouched. This demonstrates the power of isolation.

3. Merging Branches: Combining Work

Once you've completed the work on your feature branch, you'll want to integrate those changes back into your main branch. This process is called merging.

The command is simple: git merge <branch-name>.

The process is always:

1. Check out the branch you want to merge into (the receiving branch, usually main).
2. Run the git merge command with the name of the branch you want to merge from.

There are two main types of merges you'll encounter.

Fast-Forward Merge

This is the simplest case. If the receiving branch (main) hasn't had any new commits since you created your feature branch, Git can simply move the main pointer forward to the latest commit of your feature branch. No new "merge commit" is created.

The official Git documentation provides an excellent text-based walkthrough of a scenario involving a "hotfix" that results in a fast-forward merge.

Three-Way Merge

What if the main branch has changed while you were working on your feature? This is very common in team projects. In this case, Git can't just move the pointer. Instead, it performs a three-way merge.

Git looks at three commits:

1. The tip of the main branch.
2. The tip of your feature branch.
3. Their last common ancestor.

It then creates a brand new merge commit that combines the changes from both branches. This new commit is unique because it has two parents.

This text from the same Git documentation page explains this process.

Hands-on Practice: Merging Your Feature

Let's merge the README.md file you created.

1. First, make sure you are on the main branch: git checkout main.
2. Now, merge the feature branch: git merge feature/add-readme.
3. Check your files. The README.md should now be present on your main branch!
4. Since the work is merged, you can safely delete the feature branch:
   git branch -d feature/add-readme

4. Dealing with Merge Conflicts

Sometimes, the merge process isn't smooth. A merge conflict occurs when you try to merge two branches that have changed the same part of the same file. Git doesn't know which change is correct, so it stops and asks you to resolve it manually.

When a conflict happens, Git will insert conflict markers directly into the problematic file. They look like this:

<<<<<<< HEAD
This is the change from your current branch (e.g., main).
=======
This is the change from the branch you are merging.
>>>>>>> feature/some-feature

To resolve the conflict, you must:

1. Open the file and edit it to be the way you want it. This might mean keeping one version, the other, or a combination of both.
2. Remove the <<<<<<<, =======, and >>>>>>> markers.
3. Save the file.
4. Tell Git you've resolved the conflict by staging the file: git add <filename>.
5. Finalize the merge with git commit.

The following video provides a fantastic, step-by-step walkthrough of creating and resolving a merge conflict.

Conclusion

Congratulations! You've just learned one of the most transformative concepts in version control. Branching is what enables agile workflows, parallel development, and safe experimentation.

Key Takeaways:

• Branches are lightweight pointers that create isolated environments for development.
• Use git checkout -b <name> to create and switch to a new branch.
• Use git merge <name> to integrate changes from one branch into another.
• A fast-forward merge happens when the receiving branch has no new commits.
• A three-way merge happens when both branches have diverged, creating a new merge commit.
• Merge conflicts occur when the same lines are changed on both branches and must be resolved manually by editing the conflicted files, running git add, and then git commit.

In our next lesson, we will dive into how you can explore your project's history. We'll learn to use powerful commands like git log, git diff, and git blame to see the branches you've created, compare changes between commits, and find out who wrote a specific line of code.