Understanding the Fundamentals of Branching in Git

Using branches is critical to working with git, not to mention to the success of your project. The idea is this: you have a ”main” branch that you’ll do your releases from. Each time code is added to the main branch it is checked and reviewed so that the main branch stays as clean as possible.

This article is an excerpt from the book, Git for Programmers by Jesse Liberty — A comprehensive guide that equips you with actionable insights on advanced Git concepts in an engaging and straightforward way.

When you want to work on a bug or a feature, you create a new branch (often called a feature branch). This creates a copy of the code that is currently in the main branch. You can work on your feature branch without affecting the main branch at all. Once you are done, and all is working, you can then ”merge” your feature branch into the main branch:

Figure 1: First feature branch

Notice that there is a pointer named Head. This points to whatever is in your work area. In this case, we’ve branched to Feature 1 and Head shows that the code for that feature branch is now in our work area.

That is a pretty good simplification of branching but there is a good deal more to it. First, let’s see how to do it. Until now, all your code has been on the Main branch — a bad practice. We should have created a feature branch before doing any coding. That said, we can do so now.

https://odsc.com/california/#register

From the command line, you simply check out Main (putting whatever is at the tip of Main into your work area. The tip means the most recent commit). Once you are in Main you will pull from the remote repository to get the very latest version of Main. You are now ready to create your first branch. The sequence of commands looks like this:

Figure 2: Creating branch on the command line

Note that creating the branch Calculator did not check it out; you must do that as a separate step. However, if you use the -b flag, then you can create the branch and check it out at the same time:

In either case, the new branch is in the work area. But what is in that branch? Because that branch was created from Main, and we’ve not changed anything yet, the new branch is identical to the Main branch. From here they will diverge. As you add code, it will be in the new branch (Calculator) but not in the main.

Before we look at that in-depth, let’s create branches for the VisualStudio user and for the GitHub Desktop user.

The easiest way to do this (and the least confusing) is to open Windows Explorer and navigate to the VisualStudio folder (in my case, GitHub | VisualStudio | ProGitForProgrammers | ProGitForProgrammers). In that folder is a .sln file, which I will double-click on, opening Visual Studio.

Note: Don’t be confused between the VisualStudio folder (which we are using to demonstrate Git in Visual Studio) and the program itself, which we use to modify the code in all three places (CommandLine, GitHubDesktop, and VisualStudio).

It might be less confusing if you think of these as three separate programmers, each one on its own computer (mimicked here by using separate directories). Each programmer has a main branch and each one is now branching off for their own work.

We want to put this on a branch as well, and to reduce confusion we’ll call this branch Book. To create the branch, click on the Git menu and select New Branch Give the new branch the name Book, and press Create:

Figure 3: Creating a new branch in Visual Studio

When you do, a window will open on the left that lists the branches for this repository and Book will be in bold indicating that it is the current branch:

Figure 4: Branches menu in Visual Studio

Two of the users have now branched off of Main. Let’s use GitHub Desktop to create a third branch. Open the program and click on the menu choice Repository. On that menu click on Show In Explorer and make sure you are in the path C:\GitHub\GitHubDesktop\ProGitForProgrammers.

It should indicate that you have one pull from the origin (the server) and have a button that says Pull Origin. Go ahead and click that button. That brings down the latest version of Main. You now should see that the button says Push Origin — that’s to push up to the server the two commits that are now sitting in this directory.

To create your new branch, click on the Branch menu choice and select New Branch. It will prompt you for the name of your new branch. Enter Movie and click Create. The interface now asks if you want to publish your branch. Publishing in GitHub Desktop simply means uploading it for the first time. Let’s hold off on that and first make some commits.

Programmer 1 (CommandLine) and Calculator

Open Visual Studio in the CommandLine directory path. In the Solution Explorer, you should see Program.cs, which has five WriteLine statements. Add a new class named Calculator and set it to public:

Normally we would not create a commit after so little work, but for this book, to make simple examples, we’ll be doing a great deal of committing. Return to the command line and get the status. It will tell you that you have one untracked file. Git has recognized that there is a file in the directory that it knows nothing about. Our next step is to add it to git:

By using the dot, the add command will add any modified or new files to the staging area. You can then commit the new file just by writing:

If you write git status now, git will tell you that you are on the branch Calculator, that you have nothing to commit, and that your working tree is clean.

We’re going to talk about the log command in detail in the book but for now, let’s just use it to see our commit and the message that went with it:

This will display all of your commits, one per line:

The seven-digit hexadecimal identifier is the ”short SHA” and is enough to uniquely identify each commit. They are listed in newest to oldest order. Our most recent commit says:

This tells you that your Head pointer is pointing to your Calculator branch (that is, what is in your working area right now is the Calculator branch) and it displays the message we added for that commit. Graphically, it might look like this:

Figure 5: Head pointer

Notice that the arrow runs from Calculator to Main. Each commit points to its parent.

Pushing the New Branch

We can push this commit up to the server, but the server doesn’t know about this branch. When we enter git push, we get back this message:

It is saying that it could not proceed (fatal) because the current branch (which is Calculator) does not correspond to a branch on the server. Wonderfully, however, it gives us the command line to use. Just copy the command and paste it at the prompt and hit Enter. Hey, presto! You’ve pushed your branch up to the server:

Figure 6: Pushing to the server

For now, you can ignore all the other messages; what you care about is the last two lines, indicating that you now have a branch, Calculator, on the server, and that on the server it is also called Calculator.

Note that from now on, when pushing commits on the Calculator branch, you won’t have to use that line; you’ll just be able to write git push.

Examining Origin

Let’s go to GitHub and examine our new branch. Sign in and select the ProGitForProgrammers repository:

Figure 7: Repository on server

So, where is our calculator folder? Notice the button in the upper left that says Main. Drop that down and choose Calculator — which will display the contents of the Calculator branch:

Figure 8: Calculator Branch on server

You can see that the Calculator branch does have the expected file.

Adding Commits to a Branch

Let’s add another commit to our branch. Return to Visual Studio and give our Calculator class an add method:

Again, just to have lots of commits, let’s commit this. The easiest way is to combine the add and the commit and adding a message on a single line:

To see that this was in fact committed, run the log command again:

Figure 9: Tracking HEAD

If you study this for a moment, not only will you see that our commit worked (it is the first one listed) but also that we have various pointers. On the first line, we see that HEAD is pointing to our Calculator branch. Good enough.

The second line indicates that the Calculator branch on origin (GitHub) is pointing to the previous commit. We have one commit to push.

The third line shows us that Main on origin, HEAD on origin, the Main branch, and the featureOne branch are all pointing to the third most recent commit. All this is fine. We expect Calculator to have diverged from Main, and we can push our commit if we like, or we can wait until we have a few of them.

Summary

In this article, we have learned about creating branches, committing code, and how it eventually helps to move commits from the work area to the repository and from the repository to the remote repository. Learn more from the book Git for Programmers.

Original post here.

Read more data science articles on OpenDataScience.com, including tutorials and guides from beginner to advanced levels! Subscribe to our weekly newsletter here and receive the latest news every Thursday. You can also get data science training on-demand wherever you are with our Ai+ Training platform.

--

--

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
ODSC - Open Data Science

Our passion is bringing thousands of the best and brightest data scientists together under one roof for an incredible learning and networking experience.