• Master Git Branch

This document will serve as an in-depth discussion of the git rebase command. The Rebase command has also been looked at on the setting up a repository and rewriting history pages. This page will take a more detailed look at git rebase configuration and execution. Common Rebase use cases and pitfalls will be covered here.

Git itself doesn't even follow your 'master branch is master copy' paradigm except in the loosest of senses (because it needs a branch to start with), because it doesn't care what branch you branch from (or merge into). It's only when you get into the broader ecosystem tools like Github that you really start seeing this paradigm, at which point. In Git, 'master' is a naming convention for a branch. After cloning (downloading) a project from a remote server, the resulting local repository has a single local branch: the so-called 'master' branch. This means that 'master' can be seen as a repository's 'default' branch. The Git Cheat Sheet.

Rebase is one of two Git utilities that specializes in integrating changes from one branch onto another. The other change integration utility is git merge. Merge is always a forward moving change record. Alternatively, rebase has powerful history rewriting features. For a detailed look at Merge vs. Rebase, visit our Merging vs Rebasing guide. Rebase itself has 2 main modes: 'manual' and 'interactive' mode. We will cover the different Rebase modes in more detail below.

What is git rebase?

Rebasing is the process of moving or combining a sequence of commits to a new base commit. Rebasing is most useful and easily visualized in the context of a feature branching workflow. The general process can be visualized as the following:

From a content perspective, rebasing is changing the base of your branch from one commit to another making it appear as if you'd created your branch from a different commit. Internally, Git accomplishes this by creating new commits and applying them to the specified base. It's very important to understand that even though the branch looks the same, it's composed of entirely new commits.

Usage

The primary reason for rebasing is to maintain a linear project history. For example, consider a situation where the master branch has progressed since you started working on a feature branch. You want to get the latest updates to the master branch in your feature branch, but you want to keep your branch's history clean so it appears as if you've been working off the latest master branch. This gives the later benefit of a clean merge of your feature branch back into the master branch. Why do we want to maintain a 'clean history'? The benefits of having a clean history become tangible when performing Git operations to investigate the introduction of a regression. A more real-world scenario would be:

1. A bug is identified in the master branch. A feature that was working successfully is now broken.
2. A developer examines the history of the master branch using git log because of the 'clean history' the developer is quickly able to reason about the history of the project.
3. The developer can not identify when the bug was introduced using git log so the developer executes a git bisect.
4. Because the git history is clean, git bisect has a refined set of commits to compare when looking for the regression. The developer quickly finds the commit that introduced the bug and is able to act accordingly.

Learn more about git log and git bisect on their individual usage pages.

You have two options for integrating your feature into the master branch: merging directly or rebasing and then merging. The former option results in a 3-way merge and a merge commit, while the latter results in a fast-forward merge and a perfectly linear history. The following diagram demonstrates how rebasing onto the master branch facilitates a fast-forward merge.

Rebasing is a common way to integrate upstream changes into your local repository. Pulling in upstream changes with Git merge results in a superfluous merge commit every time you want to see how the project has progressed. On the other hand, rebasing is like saying, “I want to base my changes on what everybody has already done.”

Don't rebase public history

As we've discussed previously in rewriting history, you should never rebase commits once they've been pushed to a public repository. The rebase would replace the old commits with new ones and it would look like that part of your project history abruptly vanished.

Git Rebase Standard vs Git Rebase Interactive

Git rebase interactive is when git rebase accepts an -- i argument. This stands for 'Interactive.' Without any arguments, the command runs in standard mode. In both cases, let's assume we have created a separate feature branch.

Cisco asa license key generator. Git rebase in standard mode will automatically take the commits in your current working branch and apply them to the head of the passed branch.

This automatically rebases the current branch onto , which can be any kind of commit reference (for example an ID, a branch name, a tag, or a relative reference to HEAD).

Running git rebase with the -i flag begins an interactive rebasing session. Instead of blindly moving all of the commits to the new base, interactive rebasing gives you the opportunity to alter individual commits in the process. This lets you clean up history by removing, splitting, and altering an existing series of commits. It's like Git commit --amend on steroids.

This rebases the current branch onto but uses an interactive rebasing session. This opens an editor where you can enter commands (described below) for each commit to be rebased. These commands determine how individual commits will be transferred to the new base. You can also reorder the commit listing to change the order of the commits themselves. Once you've specified commands for each commit in the rebase, Git will begin playing back commits applying the rebase commands. The rebasing edit commands are as follows:

Additional rebase commands

As detailed in the rewriting history page, rebasing can be used to change older and multiple commits, committed files, and multiple messages. While these are the most common applications, git rebase also has additional command options that can be useful in more complex applications.

• git rebase -- d means during playback the commit will be discarded from the final combined commit block.
• git rebase -- p leaves the commit as is. It will not modify the commit's message or content and will still be an individual commit in the branches history.
• git rebase -- x during playback executes a command line shell script on each marked commit. A useful example would be to run your codebase's test suite on specific commits, which may help identify regressions during a rebase.

Recap

Interactive rebasing gives you complete control over what your project history looks like. This affords a lot of freedom to developers, as it lets them commit a 'messy' history while they're focused on writing code, then go back and clean it up after the fact.

Most developers like to use an interactive rebase to polish a feature branch before merging it into the main code base. This gives them the opportunity to squash insignificant commits, delete obsolete ones, and make sure everything else is in order before committing to the “official” project history. To everybody else, it will look like the entire feature was developed in a single series of well-planned commits.

The real power of interactive rebasing can be seen in the history of the resulting master branch. To everybody else, it looks like you're a brilliant developer who implemented the new feature with the perfect amount of commits the first time around. This is how interactive rebasing can keep a project's history clean and meaningful.

Configuration options

There are a few rebase properties that can be set using git config. These options will alter the git rebase output look and feel.

• rebase.stat: A boolean that is set to false by default. The option toggles display of visual diffstat content that shows what changed since the last debase.

• rebase.autoSquash: A boolean value that toggles the --autosquash behavior.

• rebase.missingCommitsCheck: Can be set to multiple values which change rebase behavior around missing commits.

warn	Prints warning output in interactive mode which warns of removed commits
error	Stops the rebase and prints removed commit warning messages
ignore	Set by default this ignores any missing commit warnings

• rebase.instructionFormat: A git log format string that will be used for formatting interactive rebase display

Advanced rebase application

The command line argument --onto can be passed to git rebase. When in git rebase --onto mode the command expands to:

The --onto command enables a more powerful form or rebase that allows passing specific refs to be the tips of a rebase.
Let’s say we have an example repo with branches like:

featureB is based on featureA, however, we realize featureB is not dependent on any of the changes in featureA and could just be branched off master.

featureA is the < oldbase >. master becomes the < newbase > and featureB is reference for what HEAD of the < newbase > will point to. The results are then:

Understanding the dangers of rebase

One caveat to consider when working with Git Rebase is merge conflicts may become more frequent during a rebase workflow. This occurs if you have a long-lived branch that has strayed from master. Eventually you will want to rebase against master and at that time it may contain many new commits that your branch changes may conflict with. This is easily remedied by rebasing your branch frequently against master, and making more frequent commits. The --continue and --abort command line arguments can be passed to git rebase to advance or reset the the rebase when dealing with conflicts.

A more serious rebase caveat is lost commits from interactive history rewriting. Running rebase in interactive mode and executing subcommands like squash or drop will remove commits from your branche's immediate log. At first glance this can appear as though the commits are permanently gone. Using git reflog these commits can be restored and the entire rebase can be undone. For more info on using git reflog to find lost commits, visit our Git reflog documentation page.

Git Rebase itself is not seriously dangerous. The real danger cases arise when executing history rewriting interactive rebases and force pushing the results to a remote branch that's shared by other users. This is a pattern that should be avoided as it has the capability to overwrite other remote users' work when they pull.

Recovering from upstream rebase

If another user has rebased and force pushed to the branch that you’re committing to, a git pull will then overwrite any commits you have based off that previous branch with the tip that was force pushed. Luckily, using git reflog you can get the reflog of the remote branch. On the remote branch's reflog you can find a ref before it was rebased. You can then rebase your branch against that remote ref using the --onto option as discussed above in the Advanced Rebase Application section.

Summary

In this article we covered git rebase usage. We discussed basic and advanced use cases and more advanced examples. Some key discussion points are:

• git rebase standard vs interactive modes
• git rebase configuration options
• git rebase --onto
• git rebase lost commits

We looked at git rebase usage with other tools like git reflog, git fetch, and git push. Visit their corresponding pages for further information.

The Internet Engineering Task Force (IETF) points out that 'Master-slave is an oppressive metaphor that will and should never become fully detached from history' as well as 'In addition to being inappropriate and arcane, the master-slave metaphor is both technically and historically inaccurate.' There's lots of more accurate options depending on context and it costs me nothing to change my vocabulary, especially if it is one less little speed bump to getting a new person excited about tech.

You might say, 'I'm all for not using master in master-slave technical relationships, but this is clearly an instance of master-copy, not master-slave.'

UPDATE: There is Good analysis of the whole main branch convo in the Git Rev News: Edition 65. Git likely uses master in the context of 'master copy' or 'master recording.'

So we see that while the word master doesn't always connote slave, for many, it's evocative via basic word-association and they just don't want to look at the word on their prompt all day. Choice is cool.

I have had dozens of git repositories that have 'master' as the main branch. Changing that would be a hassle right?

Let's see. I'll just 'git branch -m master main' and then push it back! Remember that -m is --move so your history isn't changed! Even better I can 'git push -u origin main' to set the upstream at the same time.

That was easy.

NOTE: Changing the default branch to 'main' also has the benefit of starting with 'ma' so that autocomplete <TAB> muscle memory still works. Another great option for your main github branch is 'latest.' The goal is to just be unambiguous.

Now I just need to change my default branch in my GitHub settings for my repository.

I can also update the tracking branch manually as seen here, but if you use git push -u origin main it'll do both.

The last thing to think about is if you have a CI/CD, GitHub Action, Azure DevOps pipeline or some other build system that pulls a specific branch. You'll just change that to main. However, usually unless your CI explicitly calls for a branch by name, changing master to main will 'just work!'

NOTE: For more complex repos also check your protected branch rules.

This is because -m is --move and all your reflog is unchanged!

Jvc gr dvp3 driver for mac. TL;DR in conclusion:

Updating local clones

If someone has a local clone, then can update their locals like this:

From the tweet above (Thanks Brad from XUnit.net!), these steps

1. Go to the master branch
2. Rename master to main locally
3. Get the latest commits from the server
4. Remove the link to origin/master
5. Add a link to origin/main
6. Update the default branch to be origin/main

You can add an alias 'git new' that will default to whatever starting branch you like. (NOTE: This is no longer needed, set below)

UPDATE!As of Git 2.28 you don't need an alias as above, as there is a new config option called init.DefaultBranch. Just set it and forget it.

Hope this helps! Other good names are latest, trunk, and stable!

Sponsor: Have you tried developing in Rider yet? This fast and feature-rich cross-platform IDE improves your code for .NET, ASP.NET, .NET Core, Xamarin, and Unity applications on Windows, Mac, and Linux.

About Scott

Scott Hanselman is a former professor, former Chief Architect in finance, now speaker, consultant, father, diabetic, and Microsoft employee. He is a failed stand-up comic, a cornrower, and a book author.

Master Git Branch

AboutNewsletter