Git Mastery: Understanding Remote and Tracking Branches

Remote branches help users on a specific project to collaborate. These branches are hosted on GitHub and that is more regularly referred to as the origin repository. When the user has made some local changes, it is possible to push this created local branch to the origin or remote repository. By doing this, you allow other users to get access to this specific code.

So, remote branches are copies of local branches on the remote repos.  

​Initiating a New Local Repository

For a practical understanding of how everything really functions, let’s create a local repository. To do this, start with the creation of a new directory and insert several files into it, after that run $ git init. By doing this, you can now find these specific files as untracked, to check that you can run a command - $ git status. For adding any other files, you can type - $ git commit -m. The local repository with a couple of files has been successfully created, so let’s proceed to the remote repo.    

Initiating a New Remote Repository

For the creation of the remote repository, you should first choose a needed service. The most popular options are Bitbucket and GitHub. Once you have chosen a service and set up everything, you can continue with the next steps.

Uploading Changes to a Remote Repository

After the setup of the remote repo, you will need to insert a reference to it in the local repository. To do this, you will need to type:

$ git remote add something [remote-url]

As you see, we have named this remote repository something, but it can be any other word you like. To check whether everything was connected successfully, use the command:

$ git remote

To get more detailed information about the remote repository, you will need to add -v to the command which is mentioned above.  

The next step is to push to the remote repository, by the following command:

$ git push something master

By typing this command, a master branch is created on the remote repo and the reference is created on the local repository. If you are pushing to a remote repo, but have not created a branch, it will be done automatically. The automatically generated name contains the following info remotes/remote-name/branch-name, in our situation it is remotes/something/master.

Verifying Your Remote Branches

To verify all the remote branches, you can run $ git branch -r. To review all the existing branches including local and remote, you should run:

$ git branch -a

When you are checking it for the first time, usually, the master branch and initial remote brunch will be identical. However, when other users are added to the project this branch will be also updated at some stage.

Transitioning to Remote Branches

Transition to the remote branches is easy, just type:

$ git checkout origin/master

As you see, there is no need to insert remotes/in this line. The convenience is that it is a local operation, which is possible due to the exact copy of the remote master branch.

Keeping Your Remote Branches Up-to-Date

For sending the local modifications to the remote repo, type the following command:

$ git push

It is highly recommended to start with $ git fetch before running this push command. There is no need to start with the fetch, in case you have created a new branch. Because this branch wasn’t on the remote repository, there is nothing to fetch from.

For the synchronization, you should type the following command:

$ git fetch [remote-name]

This synchronization works by copying all the remote branches into the local repository. If such branches are in the local repository, then they will be updated.

The Necessity of Running 'Fetch' Before 'Push'

‘Fetch’ should be done prior to pushing new changes into the remote repo. This is a really important thing to keep in mind before any adjustments you are planning. If another user has pushed something to the remote repository, it is needed to ‘fetch’ the changes and then to ‘merge’ these modifications into local branches. Only after that, you can start ‘pushing’ your modifications. Users could not practically push anything unless the local branch is updated.

The fetching process is equally necessary for the master branch as well as for any other branches. Remember, in case you are not planning to make a specific change to a branch, then you may not update it. These updates are important only if you are initiating changes.  

Simulating a Team Member's Contributions

To simulate a new member in the project, firstly you should create a new folder in the system. It should not be part of this repository or its subfolder. After that clone the repository, with the following command:

$ git clone [remote-url]

A couple of more steps are needed such as pointing to a new repo, committing, and pushing with the following command line:

$ git add
$ git commit -m
$ git push something master

Establishing Tracking Branches

Tracking branches are types of local branches that are directly connected with the remote ones. The usefulness of these tracking branches is in their automatic detection of the branch and server to use for pushing.

This type of branch is like others, but it includes specific tracking data.

The usual scenario of git push is the following: $ git push something master. This means that remote repo which is called something and brunch which is called master is receiving an update. In case such a branch has been already created in the remote repo, everything functions flawlessly, but otherwise, it falls. To make this process simpler we can use tracking branches.

​Creating New Tracking Branches

To illustrate what the whole process of creation of the tracking branch looks like, let’s make it out of the local master branch. The following command is used to make this branch - tracking remote master branch:

$ git push -u something master

As you see, it is really easy and there are no difficult steps in managing this process. In case you are not making any local modifications and pushing them, Git will return the message that everything is tracked from the original source.

Once you have run that command, the process is so much easier. You are just printing $ git push or pull and do whatever you want without the necessity of adding a branch name and remote name every time you want to pull or push something. The command line for pull looks the same:

$ git pull

The new branch creation is also really simple you are just adding -u to the line, and it looks like this:

$ git push -u remote-name branch-name

There is no necessity to do this during the initial push to the remote repo. You can make this adjustment whenever it is needed.

Additional Benefits of Utilizing Tracking Branches

The tracking branches are rather useful for pushing and pulling in a shorter version. Besides this thing, users can also easily determine whether they are behind or ahead when compared with the remote branch. To check this information, you should use the next command:

$ git status

If you have a regular branch, information about the update won’t be accessible as quickly. With the tracking branch, you will get an output right away. So you can determine whether there is a necessity to pull some new changes or push your modifications to the project.

If you have used that command and see the output – branch is up to date, you will need to do one more step. There is a trick here, in case another user updates the remote repo, you will still get a notification that everything is updated. That happens because the system checks the local remote branch, but not the remote repo. To get a valid result, you will need to use the fetch command and then the status command once again. So here you will see that the branch is behind.  

Automatically Gaining a Tracking Branch When Cloning

Cloning comes with lots of automatic features and no need to make lots of adjustments. When a user is cloning a repository, remote branches are created on the new repository identically as they are on the remote repository. In addition to this, the default master branch is created.

Except for this, a cloned repo also gets a setup of the local branch to track the remote branch. That’s really convenient and some users don’t even notice these features. They are just using the tracking branches and don’t bother about their creation or whatnot.

Of course, there are lots of automatic scenarios and that is fantastic, but how about other things that in not generated by default? Let’s create a real issue that can happen with any new user and try to solve it in the most effective way.

For instance, a team member has cloned a repository with some branches. The problem here is that the system automatically creates only remote branches and local master branches. Other local ones should be created by the user independently, so how to do that? When a user needs local access to a specific branch, it should be cloned from a remote one into a local one. One more important thing is adding a tracking mechanism to this cloned branch. That sounds like 2 difficult tasks, but actually, it is only one line that is:

$ git checkout -b [local-branch-name] [remote-name/branch-name]

In the output, you will see the notification that a chosen branch is set up to track the remote one.

Concluding Thoughts on Git Mastery

Now you have a basic understanding of the remote and tracking branches and how to initiate a local repository, a couple of useful commands such as pull, push, clone, fetch, and a couple of others. All this information may be a little bit confusing for the new users and that is obvious. Any new technology implementation is not an easy thing to master that requires not only basic knowledge but huge practice. Only practically, you can become more experienced with Git and a huge list of the commands that you will find out about. A great recommendation for any newcomer is to practice with commands, branches, create a couple of repositories and everything will be more understandable.

Git is not only about following commands and constant learning but more about exploring and testing the best strategies for a specific project. The more experiments you will make the easier it will be for you in the long run. Don’t waste your time and start small projects right now!  

​FAQ

What is the concept of tracking relationships in Git?

Tracking relationships or tracking branches are created as a great concept for the automation of several processes in Git. This tracking branch connects the local one to the remote one so that it will be easier to make push/pull. The tracking branch automatically knows which branch and sever to choose for pushing and pulling purposes and you don’t need to type everything manually.  

What is the significance of establishing tracking relationships?

The importance of this tracking process is in the automation and simplification of several major processes in Git. Now users should not add information about a server and specific branch every time they are doing pushing or pulling. By a single command, you can simplify this process and exclude additional information from the next process.  

What is the procedure for monitoring a remote branch?​

The procedure for monitoring a remote branch is important for collaborating with the users on the same project. Such tools as Git were initially created to establish good collaboration and help programmers track all the available changes within the project. All the different features and versions can be easily monitored only with a couple of commands that you should be aware of. For instance, to create/delete/list branches the following command can be used – git branch. Git fetch is applied for fetching references from the remote repo and saving them on the local one. Another helpful command for moving between features in one repo is git checkout.