Squashing Commits with Interactive Rebase: A Git Tutorial


Git is a distributed version control system that enables developers to track changes made to their codebase over time. It was created by Linus Torvalds in 2005 and has since become the industry standard for source code management. Git allows developers to collaborate on projects without worrying about version conflicts or losing important changes.

At its core, Git revolves around the concept of commits. A commit is a snapshot of the code at a specific point in time.

It records all changes made since the last commit and stores information about who made the change and when it was made. Commits are used to track progress, undo mistakes, and collaborate with other developers.

However, committing too frequently can result in a cluttered commit history that makes it difficult to review changes. This is where interactive rebase comes in handy.

Interactive rebase is a feature of Git that allows you to edit or combine commits before merging them into your main branch. In this tutorial, we will explore how to use interactive rebase to squash commits and streamline your commit history for easier review and collaboration with other developers.

Understanding Commits in Git

Git is a widely used distributed version control system. It was initially developed by Linus Torvalds to manage the Linux kernel source code.

A commit in Git refers to a snapshot of the codebase at a specific point in time. Commits help developers track changes made to the codebase and collaborate on projects.

Define what a commit is and its purpose

A commit in Git is similar to saving a document in Microsoft Word. It captures all changes that have been made since the last commit, including additions, deletions, and modifications. Each commit represents a specific version of the codebase, allowing developers to easily revert back or compare changes made over time.

The purpose of commits is twofold: firstly, it helps developers keep track of their work on a project and secondly, it allows them to collaborate with others by sharing their work on the project. Without commits, it would be difficult for multiple people to work on the same codebase without risking conflicts or losing work.

Discuss the anatomy of a commit (commit message, author, timestamp, changes made)

A commit consists of several components:

– Commit message: A short description that summarizes what changes were made in this particular commit.

– Author: The name or username of who created this particular commit.

– Timestamp: The date and time when this particular change was committed.

– Changes Made: A detailed list of all modifications included in this particular snapshot.

The use of descriptive commit messages can make it easier for developers to understand what changes were introduced with each modification and why those changes were necessary.

Explain how commits are tracked and organized in Git

Commits are tracked using SHA1 hashes – 40 character strings that uniquely identify each one’s contents. When you make a new modification to your codebase and commit it, Git creates a new SHA1 hash for the new commit, which is calculated based on both the changes made and metadata such as authorship and timestamp.

Git organizes commits into a tree structure called a history. Each commit has one or more parent commits – this refers to the previous snapshot of the codebase before modifications were made.

A branch refers to a specific sequence of commits with one commit acting as its “head”. Once you create a branch, each new commit is added to it.

Understanding how Git manages commits is critical to working with Git effectively. Commits provide an accurate record of changes made over time and allow developers to collaborate on projects without risking conflicts or losing work.

The anatomy of a commit highlights important metadata that helps developers understand what changes were introduced in a specific modification. Understanding how Git tracks and organizes commits can help you keep track of your project’s history.

The Problem with Small Commits

Small commits can be an efficient way to track changes made to a codebase. However, there are scenarios where they may not be desirable.

One common issue that arises with small commits is a cluttered commit history. When developers frequently commit small changes, the commit history can become difficult to read and interpret.

This can make it challenging for other developers to understand the progress of a project or review the changes that have been made. Another issue is difficulty in reviewing changes.

If multiple small commits are made within a short period of time, it can be difficult for reviewers to understand how the changes fit together and what each commit represents. This can slow down the code review process and increase the likelihood of errors slipping through.

The Benefits of Squashing Commits

Squashing commits involves combining multiple smaller commits into one larger commit. This approach has several benefits, both for individuals and teams working on collaborative projects. One benefit is improved readability of the commit history.

When small commits are squashed into larger, more meaningful ones, it becomes easier to read and track progress over time. This makes it easier for developers to understand how different parts of a project fit together and helps streamline collaboration efforts.

Another benefit is increased efficiency in reviewing code changes. By consolidating multiple smaller commits into one larger one, reviewers have fewer individual pieces of code to review and a better understanding of how those pieces fit together.

Additionally, squashing commits allows developers to create cleaner code histories that more accurately reflect their development process by emphasizing important milestones rather than every single minor change made along the way. Overall, squashing commits provides numerous benefits that help streamline collaboration efforts among team members while also making tracking progress easier for all parties involved in software development projects.

Interactive Rebase: A Step-by-step Guide

Define interactive rebase and its role in squashing commits

Interactive rebase is a powerful Git command used to modify the commit history of a branch. It allows developers to edit, delete, reorder, or combine previous commits into new ones.

When applied to squashing commits, it enables developers to merge multiple small commits into larger, more cohesive ones with meaningful commit messages. Interactive rebase is especially useful when preparing a branch for integration into a larger code base or for producing cleaner commit histories that aid in better understanding of the development process.

Provide a detailed tutorial on how to use interactive rebase to squash commits

Step 1: Identify which branch needs to be rebased Before starting an interactive rebase operation, you need to know which branch you want to change.

Use the `git log` command or any Git client tool (e.g., GitHub Desktop) to look at the existing commit history of your current branch and identify which commits you want to squash. Step 2: Open up the terminal or command prompt

Open up your computer’s terminal or command prompt application and navigate using `cd` into your project’s repository folder. Step 3: Use the git rebase command with the interactive flag (-i)

Enter `git rebase -i HEAD~N` on your terminal where `N` is the number of recent commits you want displayed on your text editor screen. This will open up an interactive text editor like Vim or Notepad that shows all recent commits in reverse-chronological order.

Step 4: Edit each commit as needed (squash) In this text editor interface, each individual commit will be shown with options next them such as “pick”, “edit”, “reword” and “squash”.

To merge multiple small commits into one, change the word “pick” to “squash” for all but the first commit. This tells Git to combine those commits into a single commit and allow you to write a new, more descriptive commit message for that new combined commit.

You can also edit other commit messages by changing the relevant “pick” command into “reword”. Save your changes and exit the editor when you are done.


Interactive rebase is an essential tool for developers who want a clean and organized commit history. Squashing commits with interactive rebase produces meaningful and descriptive commits that help developers understand the development process better.

Although it may take some time to master, once learned, this command can save you significant time in debugging and code maintenance. So why not give interactive rebasing a try today?

Related Articles