Unlocking IaC Part 5: What Is Git Branching?

*This post assumes you have worked through the previous 4 articles in this series. If you feel lost, check them out Part 1, Part 2, Part 3 & Part 4.

Back when I was first learning to code, I had this terrible habit of constantly overwriting my progress by saving the same file, repeatedly. I'd make some changes, get excited about the progress, and save over the previous version. Of course, more often than not, I'd introduce a bug or break something in the process. The concept of rolling back a change isn’t something that existed in my brain yet. It was more like “….I think this is what it was before I changed it [guesses and gets it wrong]”

If only I had known about the power of Git branches back then! Branches are one of the core features of Git that allow you to create separate lines of development, make experimental changes, or work on new features without disrupting the original codebase. It's like having the ability to create parallel universes for your code, each one isolated and independent from the others.

Imagine being able to work on a new feature, fix a bug, or try out a crazy idea without fear of breaking the existing, working code. That's the beauty of branches. You can safely make changes, commit them, and switch back to the main branch without any interference. Once you've thoroughly tested and verified your changes on the separate branch, you can then merge them back into the main codebase.

But branches aren't just for individual developers; they're also a game-changer for collaborative projects. With branches, multiple team members (or teams) can work on different parts of the codebase concurrently, without stepping on each other's toes. Each person can have their own dedicated branch, and when they're ready, their changes can be reviewed and merged into the main branch.

In this blog post, we're going to dive deep into the world of Git branches. We'll cover everything from creating and switching branches to merging and deleting them. We'll also explore common branching workflows and best practices to help you become a Git branching ninja. So, grab your keyboard and get ready to unleash the power of parallel development!

Branching Explained

In Git, you can create different "paths" for your code changes called branches. It's kind of like having multiple trails to hike on instead of just one.

The main trail is called the "master" branch, and it's where your project starts. As you make changes and save them (commit), you move further along the master trail. But what if you want to explore a new feature or try something that isn’t on the main trail? That's where new branches come in! You can create a brand new side trail (branch) that splits off from the master trail. This side trail is separate, so any changes you make on it don't affect the main trail.

In a way, branches act like bookmarks that keep track of where you are on each trail. As you make commits (save changes) on a branch, that bookmark moves further along that particular trail. You can have many different side trails (branches) at once, and you can easily switch between them. It's like having a bunch of different bookmarks, each one marking your spot on a different trail.

So, if you're working on a new feature, you can create a new branch just for that feature. Then, you can safely make all your changes and commits on that branch without disrupting the main trail (master branch) or any other side trails (branches). Once you're done with your changes on a side trail, you can merge it back into the main trail, combining your new changes with the rest of the project.

Creating a New Branch

Now that you understand what branches are, let's learn how to create a new one! Imagine you're working on your coding project, which started on the main trail (the master branch) with your initial commit. But now, you want to try adding a new feature or fixing a bug without messing up the main project. You should create a new branch instead of directly modifying the main branch.

To create a new branch, you use a special command in Git. It's kind of like saying, "Hey Git, I want to make a new trail that splits off from the main one."

The command looks like this:

git branch [new-branch-name]

So, if you want to create a new branch called "feature-login", you would type:

git branch feature-login

And just like that, you've created a new side trail called "feature-login"!

But simply creating the branch isn't enough. You also need to switch to that new trail (branch) before you can start making changes to it.

To switch to your new branch, you use another command:

git checkout [branch-name]

So, to switch to your new "feature-login" branch, you would type:

git checkout feature-login

Now, you're officially on the "feature-login" trail, and any changes or new commits you make will happen on that branch, without affecting the main trail (master branch) or any other side trails.

It's a good idea to give your branches descriptive names that remind you what they're for. For example, if you're fixing a bug, you could name the branch "fix-login-bug". That way, you'll always know which trail (branch) is for which purpose.

Switching Between Branches

So, you've created a new branch and made some changes to it. But what if you need to hop back to the main trail (the master branch) or switch to a different side trail (another branch)? That's where switching branches comes in handy!

Imagine you're hiking on your "feature-login" trail, working on a new feature for your project. But then you realize you need to fix a bug on the main trail first. Instead of trying to do both things at once (which could get messy), you can simply switch back to the master branch to fix the bug.

To switch branches, you use the same command you used to switch to your "feature-login" branch earlier:

git checkout [branch-name]

So, to switch back to the master branch, you would type:

git checkout master

And just like that, you're back on the main trail! Any changes or new commits you make now will happen on the master branch, without affecting your "feature-login" branch or any other side trails.

But what if you want to switch to a different side trail, like a branch you created for fixing a bug? No problem! You just use the same git checkout command with the name of the branch you want to switch to.

For example, if you have a branch called "fix-login-bug", you would type:

git checkout fix-login-bug

Now, you're on the "fix-login-bug" trail, and you can work on fixing that bug without disrupting any of your other branches.

It's important to remember that when you switch branches, any changes you've made on the current branch that haven't been committed yet will come with you to the new branch. This can be useful if you want to continue working on those changes on a different branch, but it can also cause conflicts if you're not careful.

That's why it's a good idea to commit your changes before switching branches, or use Git's "stash" feature to temporarily save your changes and apply them later. But I’ll cover that in a future post!

Making Changes on a Branch

Now that you know how to create and switch between branches, it's time to learn how to actually make changes on a branch!

Remember, each branch is like a separate hiking trail. When you're on a particular branch, any changes or new code you write will only affect that specific trail (branch). It won't mess up the main trail (the master branch) or any other side trails (branches) you've created.

Let's say you're working on adding a new feature to your project, like a login page. You've already created a new branch called "feature-login" and switched to it. Now, you're ready to start coding!

You can make changes to your code files just like you normally would – editing existing files, creating new ones, or deleting old ones. As you make these changes, you'll want to commit them regularly, just like you would on the main trail.

To commit your changes, you first need to tell Git which specific files you want to include in the commit. You do this with the git add command:

git add [file-name]

For example, if you've been working on a file called "login.html", you would type:

git add login.html

This tells Git to include the changes you've made to "login.html" in your next commit.

Once you've added the files you want to commit, you can create the actual commit with the git commit command:

git commit -m "Your commit message here"

The -m part lets you add a short message describing the changes you've made. For example:

git commit -m "Added basic HTML structure for login page"

Now, your changes are safely committed to the "feature-login" branch! You can keep making more changes, adding files, and committing as you go.

And remember, all of these changes and commits are happening on the "feature-login" branch only. The main trail (master branch) and any other side trails you've created remain untouched and unaffected.

Once you've finished working on the new feature and tested it thoroughly, you can merge your changes from the "feature-login" branch back into the master branch. But I am covering that in the next section!

Merging Branches

You've been hard at work on a new feature, coding away on your "feature-login" branch. After lots of commits and testing, you're finally ready to incorporate your changes into the main project!

But how do you do that? Easy – you merge your branch back into the main trail, which is called the "master" branch.

Merging is like bringing two hiking trails together. You've been exploring a side trail (your "feature-login" branch) for a while, but now, it's time to reconnect that trail with the main trail (the master branch).

To merge your branch, you first need to switch back to the master branch using the git checkout command:

git checkout master

Now, you're back on the main trail, and you're ready to merge your side trail ("feature-login") into it.

To do the merge, you use the git merge command, followed by the name of the branch you want to merge in:

git merge [branch-name]

So, to merge your "feature-login" branch, you would type:

git merge feature-login

Git will then combine (or "merge") all the commits and changes you made on the "feature-login" branch with the commits and changes on the master branch. In the best-case scenario, Git will be able to merge the two trails seamlessly, without any conflicts. However, sometimes there may be conflicts – parts of the code that Git can't automatically merge because you've made changes to the same files on both branches.

Don't worry, though! Git will let you know if there are any conflicts, and you can resolve them manually by editing the conflicting files and deciding which changes you want to keep.

Once you've resolved any conflicts (or if there weren't any to begin with), you can complete the merge process by creating a new commit that finalizes the merge. This commit will combine all the changes from both branches into a single, unified trail. After the merge is complete, you can safely delete the "feature-login" branch if you don't need it anymore, since all its changes have been incorporated into the master branch.

Merging branches might seem a bit tricky at first, but it's a crucial part of the Git workflow. It's how you take all the hard work you've done on side trails (branches) and bring it back together with the main project. Just think of it as rejoining different hiking trails – sometimes there are obstacles to overcome, but in the end, you'll have a single, unified path to follow.

Deleting Branches

After all the hard work you've done on a branch – coding, committing, and merging it back into the main trail (the master branch) – you might be wondering if you can get rid of that branch altogether. The answer is yes! Just like Arnold, you can blow it away.

But before you can delete a branch, there are a few things you need to consider:

1. Has the branch been merged? If you haven't merged the branch back into the master branch (or another branch), deleting it means you'll lose all the changes and commits you made on that branch. It's like permanently closing off a hiking trail that you haven't reconnected with the main path yet. So, make sure you merge the branch first if you want to keep those changes.

   
   

2. Are you done with the branch? Sometimes, you might want to keep a branch around for a while, even after merging it. This is especially true if you're working on a long-term project or a feature that might need more updates in the future. In that case, you can leave the branch as is and switch back to it later when you need to make more changes.

   
   

Assuming you've merged the branch and you're sure you won't need it anymore, deleting it is easy! There are two main ways to do it:

1. Deleting a merged branch If you've already merged the branch into another branch (like the master branch), you can delete it safely using the following command:

   git branch -d [branch-name]
   

   
   

   For example, to delete your "feature-login" branch that you've already merged, you would type:

   git branch -d feature-login
   

   
   

   This command tells Git to delete the branch, but only if it has been merged into another branch.

   
   

2. Deleting an unmerged branch (forced delete) If you haven't merged the branch yet, but you're absolutely sure you want to delete it (and lose all the changes and commits on that branch), you can use a "forced delete" command:

   git branch -D [branch-name]
   

   
   

   Note the capital "D" in this command. Using this, you can delete an unmerged branch, but be very careful – you can't undo this action, and all the work on that branch will be lost forever!

   
   

Once you've deleted a branch, it's gone for good (unless you have a backup or a remote copy of it somewhere). It's like permanently closing off and removing a hiking trail from the map.

Remember, it's generally a good idea to delete branches you're no longer using to keep your Git repository clean and organized. But always make sure you've merged the important changes first, or that you really don't need the branch anymore before deleting it.

With that, you've learned the basics of creating, switching, merging, and deleting branches in Git. Mastering these skills will make you a Git branching ninja, able to work on multiple features or fixes simultaneously without getting tangled up in your code!

Branching Strategies (aka Workflows)

Now that you know how to create, switch, merge, and delete branches, it's time to talk about how you can use branches effectively in your projects. Just like hikers have different strategies for exploring trails, developers have different ways of using branches to organize their work. These are called "branch workflows."

Feature Branch Workflow

One popular branch workflow is called the "Feature Branch" workflow. This is when you create a new branch for every new feature or bug fix you're working on. For example, if you're adding a new login page to your website, you'd create a branch called something like "feature-login." Once you've finished coding and testing the login page, you'd merge that branch back into the main trail (the master branch).

Release Branch Workflow

Another workflow is called the "Release Branch" workflow. This is useful when you're working on a big project with multiple versions or releases planned. Instead of putting all your changes directly into the master branch, you create a new "release" branch for each upcoming version. This way, you can keep working on the next release while the current version remains stable and unchanged.

Hotfix Branch Workflow

There's also the "Hotfix Branch" workflow, which is great for quickly fixing critical bugs in your live, production code. Instead of making the fix on the master branch (which could break things), you create a new "hotfix" branch, make the fix, and merge it back into both the master branch and any other release branches you have.

These are just a few examples of branch workflows, but there are many others, like the "Gitflow" workflow, which is a bit more complex but very popular for larger projects.

The key thing to remember is that branch workflows are just a strategy – they help you stay organized, work efficiently, and avoid getting lost or tangled up in your code. Different projects might call for different workflows, but as long as you're using branches consistently and purposefully, you'll be able to manage your code changes more effectively.

Let’s Wrap This Up…

Git branches are a powerful tool that allows you to work on new features, fix bugs, or experiment with changes without disrupting your main codebase. By understanding how to create, switch, merge, and manage branches effectively, you'll be able to streamline your development workflow, collaborate more efficiently with others, and keep your code organized and maintainable.

Mastering Git branches may seem daunting at first, but with practice and the right mental models, you'll soon be branching like a pro. Thank you for taking the time to learn about this essential Git feature – your future coding self will thank you!