Over a million developers have joined DZone.

The 2016 Git Retrospective: Rebase

DZone's Guide to

The 2016 Git Retrospective: Rebase

Rebasing is a convenient and powerful way to restructure your Git history. You can now rebase and pull with a single command, or perform a rebase exec without needing to drop into interactive mode.

· Agile Zone
Free Resource

Speed up delivery cycles and improve software quality with TestComplete. Discover the most robust automated testing tool for end-to-end desktop, mobile, and web testing. Try TestComplete Free.

Welcome to the fourth part of our Git in 2016 retrospective series! In part three, we covered changes made to Git and Git LFS to improve support for tracking large files with Git repositories. This time, we'll be looking at some enhancements made to the git rebase command throughout the year.

Image title

In March, Git v2.8 added the ability to interactively rebase whilst pulling with a git pull --rebase=interactive. Conversely, June's Git v2.9 release implemented support for performing a rebase exec without needing to drop into interactive mode via git rebase -x.


Before we dive in, I suspect there may be a few readers who aren't totally familiar or comfortable with the rebase command or interactive rebasing. Conceptually, it's pretty simple, but as with many of Git's powerful features, the rebase is steeped in some complex-sounding terminology. So, before we dive in, let's quickly review what a rebase is. 

Rebasing means rewriting one or more commits on a particular branch. The git rebase command is heavily overloaded, but the name rebase originates from the fact that it is often used to change a branch's base commit (the commit that you created the branch from).

Conceptually, rebase unwinds the commits on your branch by temporarily storing them as a series of patches, and then reapplying them in order on top of the target commit.

Image titleRebasing a feature branch on master (git rebase master) is a great way to "freshen" your feature branch with the latest changes from master. For long-lived feature branches, regular rebasing minimizes the chance and severity of conflicts down the road.

Some teams also choose to rebase immediately before merging their changes onto master in order to achieve a fast-forward merge (git merge --ff <feature> ). Fast-forwarding merges your commits onto master by simply making the master ref point at the tip of your rewritten branch without creating a merge commit:

Image title

Rebasing is so convenient and powerful that it has been baked into some other common Git commands, such as git pull. If you have some unpushed changes on your local master branch, running git pull to pull your teammates' changes from the origin will create an unnecessary merge commit:

Image title

This is kind of messy, and on busy teams, you'll get heapsof these unnecessary merge commits. git pull --rebase rebases your local changes on top of your teammates' without creating a merge commit:

Image title

This is pretty neat! Git v2.8 also introduced an even cooler feature that lets you rebase interactivelywhilst pulling.

Interactive Rebasing

Interactive rebasing is a more powerful form of rebasing. It also rewrites commits but gives you a chance to modify them as they are reapplied onto the new base.

When you run git rebase --interactive (or git pull --rebase=interactive), you'll be presented with a list of commits in your text editor of choice:

$ git rebase master --interactive

pick 2fde787 ACE-1294: replaced miniamalCommit with string in test
pick ed93626 ACE-1294: removed pull request service from test
pick b02eb9a ACE-1294: moved fromHash, toHash and diffType to batch
pick e68f710 ACE-1294: added testing data to batch email file

# Rebase f32fa9d..0ddde5f onto f32fa9d (4 commands)
# Commands:
# p, pick = use commit
# r, reword = use commit, but edit the commit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like "squash", but discard this commit's log message
# x, exec = run command (the rest of the line) using shell
# d, drop = remove commit
# These lines can be re-ordered; they are executed from top to bottom.
# If you remove a line here THAT COMMIT WILL BE LOST.

Notice that each commit has the word pick next to it. That's rebase-speak for, "Keep this commit as-is." If you quit your text editor now, it will perform a normal rebase as described in the last section. However, if you change pick to edit or one of the other rebase commands, rebase will let you mutate the commit before it is reapplied! There are several available rebase commands:

  • reword: Edit the commit message.

  • edit: Edit the files that were committed.

  • squash: Combine the commit with the previous commit (the one above it in the file), concatenating the commit messages.

  • fixup: Combine the commit with the commit above it, and uses the previous commit's log message verbatim (this is handy if you created a second commit for a small change that should have been in the original commit, i.e., you forgot to stage a file).

  • exec: Run an arbitrary shell command (we'll look at a neat use-case for this later, in the next section).
  • drop: This kills the commit.

You can also reorder commits within the file, which changes the order in which they're reapplied. This is handy if you have interleaved commits that are addressing different topics and you want to use squash or fixup to combine them into logically atomic commits.

Once you've set up the commands and saved the file, Git will iterate through each commit, pausing at each reword and edit for you to make your desired changes and automatically applying any squashfixupexec, and drop commands for you.

Non-Interactive Exec

When you rebase, you’re essentially rewriting history by applying each of your new commits on top of the specified base. git pull --rebase can be a little risky because depending on the nature of the changes from the upstream branch, you may encounter test failures or even compilation problems for certain commits in your newly created history. If these changes cause merge conflicts, the rebase process will pause and allow you to resolve them. However, changes that merge cleanly may still break compilation or tests, leaving broken commits littering your history.

However, you can instruct Git to run your project’s test suite for each rewritten commit. Prior to Git v2.9, you could do this with a combination of git rebase −−interactive and the exec command. For example, this:

$ git rebase master −−interactive −−exec=”npm test”

...would generate an interactive rebase plan that invokes npm test after rewriting each commit, ensuring that your tests still pass:

pick 2fde787 ACE-1294: replaced miniamalCommit with string in test
exec npm test
pick ed93626 ACE-1294: removed pull request service from test
exec npm test
pick b02eb9a ACE-1294: moved fromHash, toHash and diffType to batch
exec npm test
pick e68f710 ACE-1294: added testing data to batch email file
exec npm test

# Rebase f32fa9d..0ddde5f onto f32fa9d (4 command(s))

In the event that a test fails, rebase will pause to let you fix the tests (and apply your changes to that commit):

291 passing
1 failing

1) Host request “after all” hook:
Uncaught Error: connect ECONNRESET
npm ERR! Test failed.
Execution failed: npm test
You can fix the problem, and then run
        git rebase −−continue

This is handy, but needing to do an interactive rebase is a bit clunky. As of Git v2.9, you can perform a non-interactive rebase exec, with:

$ git rebase master -x “npm test”

Just replace npm test with makerakemvn clean install, or whatever you use to build and test your project.

A Word of Warning

Just like in the movies, rewriting history is risky business. Any commit that is rewritten as part of a rebase will have it's SHA-1 ID changed, which means that Git will treat it as a totally different commit. If rewritten history is mixed with the original history, you'll get duplicate commits, which can cause a lot of confusion for your team.

To avoid this problem, you only need to follow one simple rule: Never rebase a commit that you've already pushed!

Stick to that and you'll be fine.

More to Come!

We've only touched on a couple of user-facing features of git rebase. A heck of a lot of refactoring work also landed in 2016 that improved rebase performance and the robustness of interactive rebase's parsing and sequencing. This work will continue into 2017 and yield further improvements to one of Git's most unique and powerful commands. If you'd like to learn more about rebasing, check out Atlassian's great tutorial on rewriting Git history. Then keep an eye out for the next article in our retrospective series, which will cover a powerful feature with a slightly checkered past: Git submodules. 

As always, if you've got some Git tips to share, come say hi on Twitter — I'm @kannonboy.

If you stumbled on these articles out of order, you can check out the other topics covered in our Git in 2016 retrospective below:

Or, if you've read 'em all and still want more, check out Atlassian's Git tutorials (I'm a regular contributor there) for some tips and tricks to improve your workflow.

Release quality software faster with TestComplete. Discover how to decrease testing times and expand test coverage with the most robust automated UI testing tool. Try free for 30 days.

git ,version control ,rebase ,agile

Opinions expressed by DZone contributors are their own.


Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.


{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}