What is Git Branching? Full Guide to Branch Merging, Strategy, Rebase, Workflow

Branching in Git is one of the most important topics we have included in our Git Tutorial for beginners. Here, in this module, we are talking about what is git branching, merging git branches, rebase, remote branches, branching strategy and management, and more. 

If you are new to this tool, it is suggested to know what is Git and why it is used.

In Git, a branch is essentially a moveable point to these changes. In Git, the master is the default branch name. As you start making commits, you're given a master branch that points to the last commit you made. Every time you commit, the master branch pointer moves forward automatically. 

This means that if you create a new branch and make some commits, they'll be stored on that branch. Then if you switch back to the master branch and make some more commits, those will be stored on the master branch.

When you first use Git, you're given a master branch with a pointer to the last commit you made. Every time you commit, the master branch pointer moves forward automatically.

The name master is by default and doesn't mean anything special about it in the context of Git. Normally, if you're working on a project and have someone else working on it with you, their work will be on another branch, and yours will be on the master.

However, as soon as you create a new branch from the master, your work on that branch becomes independent, and at the same time, all your history up until that point is preserved.

Merging branches is a term for bringing changes from one branch into another. This is done by merging one branch into the other, which may be done in two ways: fast-forward or three-way merge.

Fast-forward merges are done when the commits on both branches are linear, or chronologically ordered. In this case, Git can automatically bring in new changes as if they were always part of history. 

Merging with a fast-forward merge can be done as a single step and takes minimal time. However, three-way merges may be necessary when the commits are not in chronological order, as shown below:

When merging branches with nonlinear histories, Git performs what is called a three-way merge (3WM). 3WMs are more complicated than fast-forwarding merges because you must specify which parts of each commit you would like to integrate into your branch.

Branches in Git can be a bit confusing at first, so let's break it down: when you make a change in Git, that change is immediately stored and can be further altered. This means that even if you only made a small change, the full history of all your changes will be stored—every single addition, deletion, and modification is tracked. This is great because it gives you the ability to revert changes whenever needed.

When you're making a lot of changes to your repository, this becomes very taxing on your system's resources. You'll notice graphical glitches or slow startup times as your system tries to load all of this data into memory every time you open up your version control tool. 

When this happens, branching allows you to get around these issues by creating a new "branch" where all of your changes are stored without affecting any other branches (such as the default branch). The reason branches are referred to as pointers is that they act as a pointer to the exact snapshot of data at which the branch was created. 

If a bug is found in your code and you need to revert back to an older version of your repository, it can be done simply by checking out the branch associated with that particular snapshot.

With the Git Feature Branch Workflow, you create one or more feature branches for new features and bug fixes. You work on the feature in a topic branch, and when you're ready to integrate it into the project, you merge that topic branch into its respective target branch. 

The steps for the Git branching workflow are:

• Create a new branch from the project's active branch (usually named "master")

• Check out the new branch

• Do your work in that branch

• Merge your changes into the base branch

Git Feature Branch Workflow is generally used when working on features, instead of bug fixes. It allows you to have one branch that will contain all your changes related to the feature you are working on while having other branches, such as master or develop, that are not affected by the new feature. Changes can be merged back into development after the feature has been completed and tested.

The Git Feature Branch Workflow is good for when there's a lot of work being done on one feature, but no other features are being worked on simultaneously. A disadvantage of this workflow is that new features will always be in the develop branch and must be manually merged into the master or another stable branch when they've been completed and tested

A programmer can use Git checkout remote branch to view the activity of a coworker or collaborator for review and cooperation. The command "Git checkout remote branch" does not exist. It's just a slang term for checking out a branch from a different location.

There are several reasons why you might want to do this. For example, if you're working on an issue with your team on GitHub, you can pull the code from your teammate's repository onto your hard drive so that you can inspect it locally. 

This is useful if your teammate is having trouble with the integration between two parts of his code or if you're not sure what he was trying to accomplish. You can also use the Git checkout remote branch to ensure that you're making changes to the right lines of code.

The Git checkout remote branch command works by using the URL at which your colleague's repository exists as a directory name. So, if your colleague's repository is located at GitHub.com/professor-geek/awesome-project, then using the Git checkout remote will check out whichever branch is named “master” in that website's directory structure

The Git rebase process involves relocating or combining a set of changes to a fresher base commit. In the framework of a feature branching approach, rebasing is perhaps the most useful and visually appealing. 

In this case, rebase can be thought of as the opposite of merging. Merging incorporates changes from one branch into another, whereas rebasing modifies a sequence of commits on one branch so that they appear to be on another branch instead.

Git rebase command is one of the most useful and powerful commands in Git. Although it can be a little tricky to wrap your head around at first, once you do, the way you use Git will change forever.

Rebasing refers to the process of shifting or consolidating a series of commits to a new base commit in a featured branched workflow (in which each branch represents a new feature). In this case, rebasing is the most practical and visible option.