Why knowing how to undo matters in Git - Visual Breakdown

Process Flow - Why knowing how to undo matters

Make a change

↓

Commit change

↓

Realize mistake

↓

Choose undo method

↓

Undo last commit

↓

Undo changes in working directory

↓

Undo pushed commits

↓

Fix mistake

↓

Continue work

This flow shows how after making and committing changes, realizing a mistake leads to choosing the right undo method to fix it and continue working.

Execution Sample

Git

git commit -m "Add feature"
git reset --soft HEAD~1
git checkout HEAD -- file.txt
git reset file.txt

This sequence commits a change, then undoes the last commit but keeps changes staged, and finally discards changes in a file.

Process Table

Step	Command	Action	Result
1	git commit -m "Add feature"	Create a new commit with changes	New commit added to history
2	git reset --soft HEAD~1	Undo last commit but keep changes staged	Commit removed, changes ready to re-commit
3	git checkout HEAD -- file.txt git reset file.txt	Discard changes in file.txt	file.txt restored to last committed state
4	git status	Check current state	No changes to commit, working directory clean

💡 All mistakes undone, working directory and commit history restored as desired

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Commit History	Initial commit	Initial commit + Add feature	Initial commit	Initial commit	Initial commit
Staged Changes	None	None	Add feature changes staged	None	None
Working Directory	Clean	Clean	Modified files from feature	Clean	Clean

Key Moments - 2 Insights

Why does 'git reset --soft HEAD~1' keep changes staged instead of discarding them?

Because '--soft' moves the HEAD pointer back but leaves the index and working directory unchanged, so changes remain staged as shown in step 2 of the execution_table.

What happens if you use 'git checkout HEAD -- file.txt' and 'git reset file.txt' after resetting the commit?

It discards changes in file.txt by restoring it to the last committed state, as seen in step 3 where the working directory file is reverted.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the state of the commit history?

A A new commit is added

B The last commit is removed but changes are still staged

C The last commit is removed and changes are discarded

D Nothing changes

💡 Hint

Refer to the 'Result' column in step 2 of the execution_table

At which step does the working directory become clean again?

A Step 1

B Step 3

C Step 4

D Step 2

💡 Hint

Check the 'Working Directory' variable in variable_tracker after each step

If you wanted to undo the last commit and discard all changes, which command would you use instead of 'git reset --soft HEAD~1'?

A git reset --hard HEAD~1

B git checkout -- file.txt

C git commit --amend

D git revert HEAD

💡 Hint

Think about which reset option discards changes completely, not just moving HEAD

Concept Snapshot

Undoing mistakes in git is crucial to keep your project clean.
Use 'git reset --soft HEAD~1' to undo last commit but keep changes staged.
Use 'git checkout HEAD -- <file>' and 'git reset <file>' to discard changes in a file.
Choose the right undo method based on whether you want to keep or discard changes.
Knowing how to undo helps fix errors quickly and safely.

Full Transcript

This lesson shows why knowing how to undo in git matters. After making and committing changes, if you realize a mistake, you can undo the last commit with 'git reset --soft HEAD~1' which keeps your changes staged for fixing. To discard changes in a file, use 'git checkout HEAD -- file.txt' and 'git reset file.txt' which restores the file to the last committed state. The execution table traces these commands step-by-step, showing how commit history, staged changes, and working directory change. Key moments clarify why '--soft' keeps changes staged and how checkout and reset discard file changes. The quiz tests understanding of commit history state, when the working directory is clean, and which command discards changes fully. This knowledge helps you fix mistakes safely and continue working confidently.

Practice

1. Why is it important to know how to undo changes in Git?

easy

A. To create new branches

B. To fix mistakes and keep the project clean

C. To add more files to the repository

D. To merge two branches

Solution

1. Step 1: Understand the purpose of undoing in Git

   Undoing helps correct errors made during development, preventing unwanted changes from affecting the project.

2. Step 2: Recognize the benefit of a clean project history

   Keeping the project clean means the history is easier to read and maintain, which is important for teamwork and future updates.

3. Final Answer:

   To fix mistakes and keep the project clean -> Option B

4. Quick Check:

   Undoing fixes mistakes [OK]

Hint: Undoing fixes errors and keeps history clean [OK]

Common Mistakes:

• Confusing undo with adding files
• Thinking undo creates branches
• Mixing undo with merging

2. Which Git command unstages files that were added to the staging area by mistake?

easy

A. git commit --amend

B. git checkout <file>

C. git reset HEAD <file>

D. git merge --abort

Solution

1. Step 1: Identify the command to unstage files

   The command git reset HEAD <file> removes files from the staging area without deleting changes.

2. Step 2: Understand why other commands don't unstage

   git commit --amend changes the last commit, git checkout <file> discards changes, and git merge --abort cancels a merge.

3. Final Answer:

   git reset HEAD <file> -> Option C

4. Quick Check:

   Unstage files = git reset HEAD [OK]

Hint: Use git reset HEAD to unstage files [OK]

Common Mistakes:

• Using git commit --amend to unstage
• Confusing checkout with unstaging
• Trying to abort merge to unstage

3. What will be the output of the following commands if you want to discard changes in a file named app.js?

git status
git checkout -- app.js
git status

medium

A. The changes in app.js are discarded and it shows as unmodified

B. The changes are staged for commit

C. The file app.js is deleted from the project

D. The last commit is undone

Solution

1. Step 1: Understand what git checkout -- app.js does

   This command discards local changes in app.js, restoring it to the last committed state.

2. Step 2: Analyze the status before and after

   Before, git status shows changes in app.js. After, it shows no changes because they were discarded.

3. Final Answer:

   The changes in app.js are discarded and it shows as unmodified -> Option A

4. Quick Check:

   Checkout discards changes [OK]

Hint: git checkout -- filename discards local changes [OK]

Common Mistakes:

• Thinking checkout stages changes
• Believing checkout deletes files
• Confusing checkout with undoing commits

4. You accidentally committed a file with sensitive data. Which command helps you undo the last commit but keep the changes in your working directory to fix the file?

medium

A. git checkout HEAD~1

B. git revert HEAD

C. git reset --hard HEAD~1

D. git reset --soft HEAD~1

Solution

1. Step 1: Understand the difference between reset options

   git reset --soft HEAD~1 moves HEAD back one commit but keeps changes staged and in the working directory.

2. Step 2: Why other options don't fit

   git revert HEAD creates a new commit undoing changes, git reset --hard HEAD~1 deletes changes, and git checkout HEAD~1 detaches HEAD without undoing commit properly.

3. Final Answer:

   git reset --soft HEAD~1 -> Option D

4. Quick Check:

   Undo last commit but keep changes = git reset --soft [OK]

Hint: Use git reset --soft to undo commit but keep changes [OK]

Common Mistakes:

• Using --hard and losing changes
• Using revert which adds a new commit
• Using checkout which detaches HEAD

5. You want to undo multiple commits but keep the changes in your working directory to edit them before recommitting. Which sequence of commands achieves this safely?

hard

A. git reset --mixed HEAD~3; git add .; git commit -m "Updated commits"

B. git revert HEAD~3..HEAD; git push

C. git reset --hard HEAD~3; git commit -m "Undo commits"

D. git checkout HEAD~3; git commit -m "Undo commits"

Solution

1. Step 1: Understand what git reset --mixed HEAD~3 does

   This command moves HEAD back 3 commits and unstages changes but keeps them in the working directory for editing.

2. Step 2: Add and recommit after editing

   After editing, git add . stages changes and git commit -m "Updated commits" creates a new commit with the corrected changes.

3. Step 3: Why other options are incorrect

   git revert creates new commits undoing changes, git reset --hard deletes changes, and git checkout detaches HEAD without undoing commits properly.

4. Final Answer:

   git reset --mixed HEAD~3; git add .; git commit -m "Updated commits" -> Option A

5. Quick Check:

   Undo commits but keep changes = git reset --mixed + add + commit [OK]

Hint: Use git reset --mixed to undo commits but keep changes [OK]

Common Mistakes:

• Using git reset --hard and losing work
• Using git revert which adds undo commits
• Using git checkout which detaches HEAD