How branches are just files with hashes in Git - Why You Should Know This

The Big Idea

What if switching your entire project version was as easy as changing a single file?

The Scenario

Imagine you are managing a big project with many versions saved as separate folders on your computer. Each time you want to switch to a different version, you have to find the right folder and copy files manually.

The Problem

This manual way is slow and confusing. You might lose track of which folder has the latest changes or accidentally overwrite important files. It's easy to make mistakes and hard to keep everything organized.

The Solution

Git branches solve this by storing the current version as a simple file that points to a unique code snapshot (called a hash). Switching branches is just changing which file points to which snapshot, making it fast and safe.

Before vs After

✗ Before

Copy folder 'version1' to 'current'; edit files there

✓ After

git checkout feature-branch

What It Enables

This lets you switch between different work versions instantly and safely, without copying or losing files.

Real Life Example

When a developer wants to try a new feature, they create a branch. They can switch back to the main project anytime without losing their work, because the branch file just points to the right snapshot.

Key Takeaways

Branches are simple files storing pointers to code snapshots.

This makes switching versions fast and error-free.

It helps developers work on multiple features safely.

Practice

1. What does a Git branch file store internally?

easy

A. A commit hash pointing to a specific commit

B. The entire project files

C. The list of all branches

D. The commit message text

Solution

1. Step 1: Understand what a branch represents

   A branch in Git is a pointer to a commit, not the files themselves.

2. Step 2: Identify what is stored in the branch file

   The branch file stores the commit hash it points to, which identifies the commit.

3. Final Answer:

   A commit hash pointing to a specific commit -> Option A

4. Quick Check:

   Branch file = commit hash [OK]

Hint: Branches store commit hashes, not files or messages [OK]

Common Mistakes:

• Thinking branches store full project files
• Confusing branch files with commit messages
• Assuming branches list all other branches

2. Which command shows the content of the branch file for main in Git?

easy

A. git show main

B. cat .git/refs/heads/main

C. git branch main

D. git log main

Solution

1. Step 1: Locate branch files in Git directory

   Branch files are stored in .git/refs/heads/ folder.

2. Step 2: Use a command to read the branch file content

   The cat command reads the file content, showing the commit hash.

3. Final Answer:

   cat .git/refs/heads/main -> Option B

4. Quick Check:

   Read branch file with cat [OK]

Hint: Branch files are plain files under .git/refs/heads/ [OK]

Common Mistakes:

• Using git show which shows commit details, not raw hash
• Using git branch which lists branches, not file content
• Using git log which shows commit history, not branch file

3. Given the branch file .git/refs/heads/feature contains abc1234, what does git checkout feature do?

medium

A. Creates a new commit with hash abc1234

B. Deletes the feature branch

C. Moves HEAD to commit abc1234 and updates working files

D. Shows the commit message of abc1234

Solution

1. Step 1: Understand what git checkout does with a branch

   It moves the HEAD pointer to the commit the branch points to.

2. Step 2: Connect branch file content to checkout effect

   The branch file has commit hash abc1234, so checkout moves HEAD there and updates files.

3. Final Answer:

   Moves HEAD to commit abc1234 and updates working files -> Option C

4. Quick Check:

   Checkout moves HEAD to branch commit [OK]

Hint: Checkout moves HEAD to branch's commit hash [OK]

Common Mistakes:

• Thinking checkout deletes branches
• Confusing checkout with commit creation
• Assuming checkout only shows commit messages

4. You see that .git/refs/heads/dev file is empty. What problem will this cause?

medium

A. Git will ignore the dev branch and use main instead

B. Git will create a new commit automatically

C. Git will treat dev as a remote branch

D. Git cannot find the commit for branch dev, causing errors on checkout

Solution

1. Step 1: Understand branch file role in Git

   The branch file must contain a commit hash to point to a commit.

2. Step 2: Analyze effect of empty branch file

   If empty, Git cannot find the commit, so checkout or other commands fail with errors.

3. Final Answer:

   Git cannot find the commit for branch dev, causing errors on checkout -> Option D

4. Quick Check:

   Empty branch file breaks commit reference [OK]

Hint: Branch files must have commit hashes, never be empty [OK]

Common Mistakes:

• Assuming Git auto-fixes empty branch files
• Confusing empty branch file with remote branch
• Thinking Git defaults to main silently

5. You want to create a new branch release pointing to the same commit as main. Which command correctly updates the branch file?

hard

A. git checkout -b release main

B. git branch release main

C. A and B

D. echo $(cat .git/refs/heads/main) > .git/refs/heads/release

Solution

1. Step 1: Understand how branches point to commits

   Branches are files storing commit hashes. Copying main's hash creates release at same commit.

2. Step 2: Analyze each option's effect

   echo $(cat .git/refs/heads/main) > .git/refs/heads/release manually copies the hash file content. git branch release main creates branch release at main's commit. git checkout -b release main creates and switches to release at main's commit.

3. Step 3: Confirm which options update branch file correctly

   Options A, B, and D all create the release branch pointing to main's commit, but only D is a single command that creates and switches to the branch.

4. Final Answer:

   git checkout -b release main -> Option A

5. Quick Check:

   git checkout -b creates and switches branch [OK]

Hint: Multiple ways to set branch file to same commit hash, but checkout -b is most common [OK]

Common Mistakes:

• Thinking only git commands can create branches
• Ignoring manual file editing possibility
• Confusing checkout with branch creation only