Why understanding internals matters in Git - Why It Works

Introduction

Git helps you save and track changes in your code. Understanding how Git works inside helps you fix problems and use it better.

When you accidentally delete a branch and want to recover it.

When you want to understand why a merge caused conflicts.

When you need to clean up your commit history safely.

When you want to know how Git stores your files and changes.

When you want to troubleshoot why a push or pull failed.

Commands

Shows a simple list of recent commits with their short IDs and messages to understand the commit history.

Terminal

git log --oneline

Expected Output

a1b2c3d Fix typo in README

4e5f6g7 Add user login feature

8h9i0j1 Initial commit

→

--oneline - Shows each commit in one short line for easy reading.

Shows a history of all your Git actions, including commits, checkouts, and resets, helping you find lost commits.

Terminal

git reflog

Expected Output

a1b2c3d HEAD@{0}: commit: Fix typo in README

4e5f6g7 HEAD@{1}: commit: Add user login feature

8h9i0j1 HEAD@{2}: commit (initial): Initial commit

Checks the Git database for dangling commits or objects that are not referenced, helping recover lost data.

Terminal

git fsck --lost-found

Expected Output

Checking object directories: 100% (256/256), done.

dangling commit 9k8l7m6

→

--lost-found - Places lost objects into .git/lost-found for recovery.

Key Concept

If you remember nothing else from this pattern, remember: knowing how Git stores and tracks your work helps you recover mistakes and use Git confidently.

Common Mistakes

Deleting branches or commits without knowing how to recover them.

You might lose important work permanently if you don't understand Git's internal tracking.

Use git reflog and git fsck to find and restore lost commits before deleting anything permanently.

Ignoring the commit history and blindly resetting or rebasing.

This can cause confusion and loss of work if you don't understand how commits link together.

Review git log and understand commit relationships before rewriting history.

Summary

Use git log --oneline to see a simple commit history.

Use git reflog to track all Git actions and recover lost commits.

Use git fsck --lost-found to find dangling objects and recover data.

Practice

1. Why is it important to understand that Git stores data as snapshots rather than just changes?

easy

A. Because Git only saves the latest file version, not history.

B. Because it helps you understand how Git tracks file versions efficiently.

C. Because Git stores files as plain text only.

D. Because Git does not keep any record of changes.

Solution

1. Step 1: Understand Git's storage method

   Git saves snapshots of the entire project state at each commit, not just the differences.

2. Step 2: Recognize the benefit of snapshots

   This method allows Git to track versions efficiently and restore any commit quickly.

3. Final Answer:

   Because it helps you understand how Git tracks file versions efficiently. -> Option B

4. Quick Check:

   Git stores snapshots = Efficient version tracking [OK]

Hint: Remember: Git snapshots whole project states, not just diffs [OK]

Common Mistakes:

• Thinking Git stores only changes, not snapshots
• Believing Git saves only the latest version
• Assuming Git stores files as plain text only

2. Which of the following commands correctly shows the commit that a branch points to?

easy

A. git branch -v

B. git commit -p

C. git show-branch

D. git checkout

Solution

1. Step 1: Identify command to list branches with commit info

   The command git branch -v lists branches and shows the commit each points to.

2. Step 2: Check other options

   git show-branch shows branch history but is less direct; git commit -p is invalid; git checkout switches branches.

3. Final Answer:

   git branch -v -> Option A

4. Quick Check:

   Branch commit info = git branch -v [OK]

Hint: Use 'git branch -v' to see branch pointers quickly [OK]

Common Mistakes:

• Using git commit -p which is invalid
• Confusing git checkout with showing commits
• Assuming git show-branch directly shows pointers

3. Given this sequence of commands:

git init
echo 'Hello' > file.txt
git add file.txt
git commit -m 'Add file'
echo 'World' >> file.txt
git commit -am 'Update file'

What will git log --oneline show?

medium

A. One commit: 'Add file' only

B. Two commits: 'Add file' on top, then 'Update file'

C. Two commits: 'Update file' on top, then 'Add file'

D. No commits because second commit is missing git add

Solution

1. Step 1: Analyze the commit sequence

   First commit adds 'file.txt' with 'Hello'. Second commit uses -am to commit changes including 'World' appended to file.

2. Step 2: Understand git log output order

   git log --oneline shows newest commit first, so 'Update file' is on top, then 'Add file'.

3. Final Answer:

   Two commits: 'Update file' on top, then 'Add file' -> Option C

4. Quick Check:

   Latest commit first in log = 'Update file' then 'Add file' [OK]

Hint: git log shows newest commit first [OK]

Common Mistakes:

• Thinking second commit needs git add with -am
• Assuming git log shows oldest commit first
• Believing only one commit exists

4. You ran git commit -m 'Fix bug' but forgot to stage changes. What is the problem and how to fix it?

medium

A. No changes were committed because files were not staged; run git add first.

B. Commit message is missing; add a message with -m.

C. You need to run git push before commit.

D. Git automatically stages files, so no fix needed.

Solution

1. Step 1: Identify why commit did not include changes

   Git commits only staged changes; if files are not staged with git add, commit is empty.

2. Step 2: Fix by staging files before commit

   Run git add <files> to stage changes, then commit again.

3. Final Answer:

   No changes were committed because files were not staged; run git add first. -> Option A

4. Quick Check:

   Stage changes before commit = git add first [OK]

Hint: Always stage files with git add before commit [OK]

Common Mistakes:

• Assuming commit stages files automatically
• Confusing commit message with staging
• Thinking git push affects commit staging

5. You want to create a new branch pointing to the same commit as main without switching branches. Which command uses Git internals correctly?

hard

A. git clone main new-feature

B. git checkout -b new-feature main

C. git reset --hard main

D. git branch new-feature main

Solution

1. Step 1: Understand branch creation without switching

   git branch new-feature main creates a new branch pointer at main's commit without changing HEAD.

2. Step 2: Check other options

   git checkout -b creates and switches; git reset changes HEAD; git clone copies repos, not branches.

3. Final Answer:

   git branch new-feature main -> Option D

4. Quick Check:

   Create branch pointer only = git branch new-feature main [OK]

Hint: Use 'git branch new-branch base-branch' to create without switching [OK]

Common Mistakes:

• Using git checkout -b which switches branches
• Confusing git reset with branch creation
• Trying to clone a branch instead of creating one