Branching for Features and Fixes

What is a Branch and Why Do You Need It?

Imagine you're working on a project. The main version of the code, often called main or master, is stable and working. Now, you want to add a new feature. If you start making changes directly to the main codebase, you risk introducing bugs or leaving it in an unstable, half-finished state. What if a critical bug is discovered in the live version while you're in the middle of your work?

This is the exact problem that branching solves.

As the video explains, a branch is essentially an independent line of development. You can create a new branch from the main line, work on your feature there, and then, when it's complete and tested, merge it back. Meanwhile, the main branch remains clean and stable.

From a technical perspective, a branch in Git isn't a full copy of your project. It's much simpler.

A branch is just a simple pointer to a specific commit. This makes creating and switching between branches nearly instantaneous, which is why Git encourages their frequent use.

This method of working on dedicated branches is so common that it has a name: the Feature Branch Workflow.

Creating and Switching Branches

Let's get practical. The core commands for branching are straightforward. First, you'll need a practice repository. Open your terminal and run these commands:

# Create a new directory for our practice project and navigate into it
mkdir git-branch-practice
cd git-branch-practice

# Initialize a new Git repository
git init

# Create a file and make our first commit
echo "Version 1" > file.txt
git add file.txt
git commit -m "Initial commit"

# Make a second commit
echo "Version 2" >> file.txt
git add file.txt
git commit -m "Add version 2"

You now have a simple project with two commits on the main branch.

The HEAD Pointer

Before we create a branch, you need to know about HEAD. In Git, HEAD is a special pointer that indicates your current working branch. Any new commits you make will be added to the branch that HEAD points to.

Creating, Switching, and Committing

Let's simulate the workflow of starting a new feature. We'll create a new branch called new-feature.

# Create a new branch named 'new-feature'
git branch new-feature

You've created the branch, but you haven't switched to it yet. Your HEAD is still pointing to main. To start working on the new branch, you need to "check it out."

# Switch to the new-feature branch
git checkout new-feature

Now, HEAD points to new-feature. Any changes you make will be on this branch. Let's make a change:

# Add a feature-specific line to our file
echo "Feature A work" >> file.txt
git add file.txt
git commit -m "Start developing Feature A"

Your new-feature branch is now one commit ahead of main.

Modern Commands: git switch

In recent versions, Git introduced the git switch command, which is more explicit for changing branches. It's now the recommended command for this task.

From now on, we'll use git switch. To go back to our main branch:

git switch main

Notice that if you open file.txt, the "Feature A work" line is gone! That's because it only exists on the new-feature branch. Your working directory reflects the state of the branch you are currently on.

The All-in-One Shortcut

Creating a branch and immediately switching to it is so common that there's a shortcut.
Using the new git switch command:

# Create a branch 'another-feature' and switch to it
git switch -c another-feature

The -c flag stands for "create". The older, but still very common, way to do this is git checkout -b another-feature.

Simulating a Full Workflow

Let's use a video to walk through a complete, realistic scenario: you're working on a feature, and your manager asks you to fix an urgent bug.

After following the video's example, you can always visualize your repository's history using this powerful command:

git log --oneline --graph --all --decorate

This will show you a text-based graph of your branches, where they diverge, and where each branch pointer (and HEAD) is currently located.

Managing Your Branches

Once you start creating branches, you'll need to know how to manage them. The freeCodeCamp.org "Git Branches Tutorial" covers these management tasks concisely.

Renaming and Deleting Branches

You might want to rename a branch for clarity or delete it after its changes have been merged.

Key Commands for Branch Management:

• git branch: Lists all your local branches.
• git branch -m <new-name>: Renames the current branch.
• git branch -d <branch-name>: Deletes a merged branch (a safety feature).
• git branch -D <branch-name>: Force-deletes a branch, even if it has unmerged changes. Use with caution!

Branches and Collaboration: Pushing to a Remote

So far, all our branches have been local—they exist only on your machine. To collaborate, you need to share your branch by "pushing" it to a remote repository (like GitHub).

This is the first step in creating a Pull Request, which you'll learn about in a future lesson.

The command git push -u origin <branch-name> does two things:

1. It pushes your branch and all its commits to the remote repository named origin.
2. The -u flag (short for --set-upstream) creates a tracking connection between your local branch and the new remote branch. This means that in the future, you can simply run git push from that branch, and Git will know where to send your changes.

This is the standard way to share your work when contributing to an open-source project.

Conclusion

Fantastic work! You've just mastered one of the most critical concepts in Git. You now have the skills to work on features and fixes in a clean, isolated, and professional manner.

Key Takeaways:

• Branches provide isolated environments for development, keeping the main branch stable. This is the Feature Branch Workflow.
• A branch is a lightweight, movable pointer to a commit.
• Use git switch -c <branch-name> to create and switch to a new branch. Use git switch <branch-name> to move between existing branches.
• HEAD is a special pointer that indicates your currently active branch.
• Visualize your project's history with git log --graph --all.
• Manage branches with commands like git branch -m (rename) and git branch -d (delete).
• Share your branch with collaborators by running git push -u origin <branch-name>.

Preview of the next lesson: You're now creating commits on separate branches, which is a big step. But what goes inside those commits? Specifically, the commit message is a vital form of communication with other developers. In our next lesson, we will focus on how to write clear and meaningful commit messages that follow established conventions, making your contributions easy for others to understand.