How to Squash Commits in GitHub?

In the world of software development, maintaining a clean and organized commit history is crucial for collaboration and project management. Squashing commits is a technique that allows developers to combine multiple commits into a single commit, making the history more concise and easier to read. This process can be particularly useful when you have numerous minor commits that clutter your history, such as incremental changes or fixes. In this blog post, we will walk you through the steps to squash commits in GitHub, including when to use this technique and best practices.

Why Squash Commits?

Squashing commits serves several important purposes:

• Cleaner History: It helps keep the commit history tidy and focused, making it easier for other developers to understand the evolution of the project.
• Logical Grouping: It allows you to group related changes into a single commit, which can provide better context for future references.
• Improved Collaboration: A clean commit history can enhance collaboration by making it easier to review changes and identify bugs.

When to Squash Commits

• Before merging a feature branch into the main branch to consolidate changes and ensure that only meaningful commits are preserved.
• After completing a feature, when you want to tidy up the history before sharing your work with others.
• During code review processes, when you want to provide a more streamlined set of changes.

Step-by-Step Guide to Squashing Commits

Step 1: Open Your Terminal

Open your terminal or command prompt and navigate to the local repository where you want to squash commits.

Step 2: Check Your Commit History

Before squashing commits, it’s helpful to see the existing commit history. Use the following command:

git log --oneline

This command displays a compact view of the commit history, showing the commit hashes and messages.

Step 3: Start an Interactive Rebase

To squash commits, you will use Git’s interactive rebase feature. Determine how many commits you want to squash. For example, if you want to squash the last three commits, you would run:

git rebase -i HEAD~3

This command opens an editor displaying the last three commits, where you can specify how to treat each commit.

Step 4: Edit the Commit List

In the interactive rebase editor, you will see a list of commits in the following format:

pick 1a2b3c4 Commit message 1
pick 2b3c4d5 Commit message 2
pick 3c4d5e6 Commit message 3

To squash commits, change the word pick to squash (or s) for the commits you want to squash into the previous commit:

pick 1a2b3c4 Commit message 1
squash 2b3c4d5 Commit message 2
squash 3c4d5e6 Commit message 3

This setup will keep the first commit intact while squashing the subsequent commits into it.

Step 5: Save and Exit the Editor

After editing the commit list, save your changes and exit the editor. The method to do this depends on the editor you are using:

• For Vim: Press Esc, type :wq, and hit Enter.
• For Nano: Press Ctrl + X, then Y to confirm saving, and hit Enter.

Step 6: Edit the Commit Message

After exiting the editor, Git will present a new editor window prompting you to edit the commit message for the combined commit. You can keep the original message, combine messages, or write a new one.

Save and exit the editor again to complete the squashing process.

Step 7: Force Push the Changes (If Necessary)

If you have already pushed the original commits to a remote repository, you will need to force push the changes because squashing alters the commit history:

git push origin <branch-name> --force

Replace <branch-name> with the name of your branch. Note: Force pushing can overwrite changes in the remote repository, so ensure you coordinate with your team before doing this.

Best Practices for Squashing Commits

• Squash Before Merging: Always squash your commits before merging a feature branch into the main branch to keep the history clean.
• Communicate with Your Team: If you are working in a team, inform your collaborators when you plan to force push after squashing commits to avoid confusion.
• Use Meaningful Commit Messages: When squashing commits, make sure to write clear and meaningful commit messages that accurately describe the changes being made.
• Avoid Squashing Public Commits: Be cautious when squashing commits that have already been shared with others. It’s generally best to squash only commits that have not yet been published.

Conclusion

Squashing commits is a valuable technique in Git that helps maintain a clean and organized commit history. By following the steps outlined in this guide, you can effectively squash your commits, making your project easier to navigate and understand.

By embracing best practices and communicating with your team, you can enhance collaboration and streamline your development workflow. Whether you are preparing for a code review or merging your feature branch, knowing how to squash commits will make your code management more efficient.