Why recovery skills are critical in Git - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is it important to know how to recover lost commits in Git?

Imagine you accidentally deleted some commits in your Git repository. Why is it important to know how to recover them?

A Because lost commits can contain important work that might be hard to redo.

B Because Git automatically deletes all commits after 24 hours.

C Because recovering commits speeds up the computer performance.

D Because commits are only stored locally and cannot be pushed again.

💡 Hint

Think about what happens if you lose work you spent time on.

Lost commits may contain valuable changes. Knowing recovery helps avoid losing work and saves time.

💻 Command Output

intermediate

What is the output of 'git reflog' after resetting a branch?

After running git reset --hard HEAD~1, what does git reflog show?

Git

git reset --hard HEAD~1
git reflog

A Shows the previous HEAD positions including the reset commit.

B Shows only the current HEAD commit, no history.

C Shows an error because reflog is disabled by default.

D Shows the commit history from the remote repository.

💡 Hint

Reflog records where HEAD has been recently.

Reflog keeps track of all recent HEAD changes, including resets, allowing recovery.

🔀 Workflow

advanced

Which sequence correctly recovers a deleted branch in Git?

You accidentally deleted a branch named feature. Which sequence of commands will recover it?

A git reset --hard feature; git checkout feature

B git reflog; git checkout -b feature <commit-hash>

C git branch feature; git push origin feature

D git clone feature; git checkout feature

💡 Hint

Think about how to find the commit hash of the deleted branch.

Using git reflog helps find the last commit hash of the deleted branch, then git checkout -b recreates it.

❓ Troubleshoot

advanced

What error occurs if you try to recover a commit with a wrong hash?

You run git checkout -b fix . What error will Git show?

A error: branch 'fix' already exists

B error: cannot checkout detached HEAD

C fatal: not a git repository

D fatal: reference is not a tree: <wrong-hash>

💡 Hint

Think about what happens if the commit hash does not exist.

Git reports 'fatal: reference is not a tree' when the commit hash is invalid or not found.

✅ Best Practice

expert

What is the best practice to avoid losing work in Git?

Which practice helps prevent losing commits accidentally?

A Delete old branches immediately after merging without backup.

B Only work on the main branch and avoid pushing until the project is finished.

C Regularly push commits to a remote repository and use branches for features.

D Use <code>git reset --hard</code> frequently to clean history.

💡 Hint

Think about how backups and isolation help protect work.

Pushing to remote and using branches isolates work and creates backups, reducing risk of loss.

Practice

1. Why are recovery skills important when using git?

easy

A. They speed up the commit process

B. They help fix mistakes without losing work

C. They automatically merge branches

D. They delete old branches permanently

Solution

1. Step 1: Understand the purpose of recovery skills

   Recovery skills allow you to undo or fix errors safely in your code history.

2. Step 2: Identify the benefit of recovery skills

   They prevent loss of work by enabling you to restore previous states or undo changes.

3. Final Answer:

   They help fix mistakes without losing work -> Option B

4. Quick Check:

   Recovery skills = Fix mistakes safely [OK]

Hint: Recovery means fixing errors without losing code [OK]

Common Mistakes:

• Thinking recovery speeds commits
• Confusing recovery with merging
• Believing recovery deletes branches

2. Which git command is used to view the history of changes including those not on any branch?

easy

A. git revert

B. git reset

C. git reflog

D. git status

Solution

1. Step 1: Identify command purpose

   git reflog shows a log of all changes to HEAD, including commits that are no longer referenced by branches.

2. Step 2: Compare with other commands

   git reset changes HEAD, git revert creates new commits to undo changes, and git status shows current state.

3. Final Answer:

   git reflog -> Option C

4. Quick Check:

   History including lost commits = git reflog [OK]

Hint: Use reflog to see all HEAD changes, even lost commits [OK]

Common Mistakes:

• Using git reset to view history
• Confusing git revert with reflog
• Thinking git status shows past commits

3. What is the output of the following commands sequence?

git commit -m "First"
git commit -m "Second"
git reset --soft HEAD~1
git status

medium

A. Shows no changes to commit, working tree clean

B. Shows unstaged changes from the "Second" commit

C. Shows an error about HEAD~1

D. Shows staged changes from the "Second" commit

Solution

1. Step 1: Understand git reset --soft HEAD~1

   This command moves HEAD back one commit but keeps changes from that commit staged.

2. Step 2: Check git status after reset

   Since changes are staged, git status will show them ready to commit.

3. Final Answer:

   Shows staged changes from the "Second" commit -> Option D

4. Quick Check:

   Soft reset = staged changes [OK]

Hint: Soft reset keeps changes staged for commit [OK]

Common Mistakes:

• Thinking reset deletes changes
• Confusing staged and unstaged changes
• Expecting error from HEAD~1

4. You accidentally deleted your branch with git branch -D feature. Which command helps you recover it?

medium

A. git reflog

B. git revert feature

C. git reset feature

D. git checkout -b feature

Solution

1. Step 1: Understand branch deletion impact

   Deleting a branch removes its reference but commits remain in reflog temporarily.

2. Step 2: Use git reflog to find commit

   git reflog shows recent HEAD movements, allowing you to find the commit hash to restore the branch.

3. Step 3: Restore branch with commit hash

   After finding the commit, use git branch feature <commit-hash> to recover the branch.

4. Final Answer:

   git reflog -> Option A

5. Quick Check:

   Recover deleted branch = git reflog [OK]

Hint: Use reflog to find lost commits and restore branches [OK]

Common Mistakes:

• Trying git revert on deleted branch
• Using git reset without commit hash
• Creating branch without commit reference

5. You committed a change but realize it breaks the build. You want to undo the commit but keep your changes to fix them. Which sequence is best?

hard

A. git reset --soft HEAD~1

B. git reset --hard HEAD~1

C. git checkout -- .

D. git revert HEAD; git commit -m "fix"

Solution

1. Step 1: Understand the goal

   You want to undo the last commit but keep the changes staged to fix and recommit.

2. Step 2: Analyze options

   git reset --soft HEAD~1 moves HEAD back but keeps changes staged. git revert creates a new commit undoing changes, git reset --hard deletes changes, and git checkout -- . discards changes.

3. Final Answer:

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

4. Quick Check:

   Undo commit but keep changes staged = soft reset [OK]

Hint: Soft reset undoes commit but keeps changes staged [OK]

Common Mistakes:

• Using hard reset and losing changes
• Revert creates extra commits
• Checkout discards all changes