How to Roll back from a git commit ?

Introduction

Rolling back a Git commit is a common task that every sysadmin and developer should master. Whether due to a coding error, an incorrect commit message, or changes that are no longer necessary, knowing how to effectively revert to a previous state in your project’s history is crucial for maintaining a clean and functional codebase. This article will guide you through the process of rolling back a Git commit, explain the underlying concepts, and provide best practices to avoid common pitfalls.

What Is Rolling Back in Git?

Rolling back in Git refers to the process of reverting to a previous state in your project’s history by undoing recent changes that have been committed to the repository. This is essential for maintaining a stable development workflow, as it allows you to correct mistakes without losing your entire project history. Git provides multiple strategies for rolling back commits, with the primary commands being git reset and git revert, each serving different scenarios.

How It Works

To understand how rolling back works in Git, think of your project history as a timeline. Each commit is a point on this timeline, and rolling back means moving back to a previous point.

HEAD: This represents the most recent commit in your current branch. Using HEAD^ refers to the commit immediately before the last one.
Unstaged vs. Staged Changes: Unstaged changes are modifications in your working directory that haven’t been added to the staging area with git add. Staged changes are those that are ready to be committed.
Amend: The git commit --amend command allows you to modify the last commit, including changing the commit message or adding files.

Prerequisites

Before you start rolling back commits, ensure you have the following:

Git installed on your machine.
A local Git repository with at least one commit.
Basic knowledge of Git commands and concepts.

Installation & Setup

If you don't have Git installed, you can set it up using the following commands based on your operating system:

For Ubuntu/Debian:

sudo apt update
sudo apt install git

For macOS:

brew install git

For Windows:

Download and install Git from the official website.

Step-by-Step Guide

Here’s how to roll back a commit in various scenarios:

Scenario 1: Undo the Last Commit and Keep Changes Unstaged

Make a commit:
```
git commit -m "Initial commit"
```
Realize you want to undo this commit but keep the changes:
```
git reset HEAD^
```
Your files are now back in your working directory, allowing you to modify them as needed.

Scenario 2: Undo the Last Commit and Discard Changes

Make a commit:
```
git commit -m "Add new feature"
```
Decide to completely discard this commit:
```
git reset --hard HEAD^
```
This command removes the last commit and all associated changes permanently.

Scenario 3: Reverting a Commit in a Shared Repository

Identify the commit hash you want to revert:
```
git log
```
Use git revert to create a new commit that undoes the changes:
```
git revert <commit-hash>
```
This method is safe for shared repositories as it preserves the commit history.

Real-World Examples

Example 1: Fixing a Mistaken Commit Message

You accidentally committed with the wrong message. To amend it:

git commit --amend -m "Correct commit message"

Example 2: Discarding Unwanted Changes

You pushed a commit that introduced a bug. To revert it in a shared repository:

git revert <commit-hash>

This creates a new commit that undoes the changes of the specified commit.

Best Practices

Always double-check your changes before committing.
Use git log to view your commit history before rolling back.
Prefer git revert over git reset in shared repositories to maintain history.
Keep your commits small and focused to make rollbacks easier.
Use descriptive commit messages to avoid confusion when rolling back.

Common Issues & Fixes

Issue	Cause	Fix
Lost changes after `git reset --hard`	Unintended use of hard reset	Always back up changes before using hard reset.
Conflicts when reverting a commit	Changes in the same area of code	Resolve conflicts manually during the revert process.
Incorrect commit hash used	Typo in the commit hash	Verify the hash with `git log` before reverting.

Key Takeaways

Rolling back a commit is essential for maintaining a clean project history.
Understand the difference between git reset and git revert for different scenarios.
Always back up your work before performing destructive operations.
Use git log to track your commit history effectively.
Follow best practices to avoid common pitfalls when rolling back commits.

By mastering these techniques, you can effectively manage your Git repository and maintain a stable development environment.