How branches are just files with hashes in Git - Step-by-Step CLI Walkthrough

Introduction

Branches in Git are simple files that store the hash of the latest commit. This means a branch is just a pointer to a specific commit in the project history.

When you want to understand how Git tracks changes behind the scenes

When you need to debug branch-related issues by looking at Git internals

When you want to manually inspect or manipulate branch pointers

When you want to explain Git branching to someone new using simple concepts

When you want to see how Git stores branch information in the .git directory

Commands

Create a new Git repository named example-repo to start tracking files and commits.

Terminal

git init example-repo

Expected Output

Initialized empty Git repository in /path/to/example-repo/.git/

Change directory into the new repository to run Git commands inside it.

Terminal

cd example-repo

Expected Output

No output (command runs silently)

Create a new file named file.txt with the content 'Hello'.

Terminal

echo "Hello" > file.txt

Expected Output

No output (command runs silently)

Stage the new file so Git knows to include it in the next commit.

Terminal

git add file.txt

Expected Output

No output (command runs silently)

Create the first commit with the staged file and a message describing the change.

Terminal

git commit -m "Add file.txt with Hello"

Expected Output

[master (root-commit) abcdef1] Add file.txt with Hello

 1 file changed, 1 insertion(+)

 create mode 100644 file.txt

→

-m - Add a commit message inline

Show the content of the master branch file, which is the hash of the latest commit it points to.

Terminal

cat .git/refs/heads/master

Expected Output

abcdef1234567890abcdef1234567890abcdef12

Display the commit history in a short format to see the commit hash and message.

Terminal

git log --oneline

Expected Output

abcdef1 Add file.txt with Hello

→

--oneline - Show each commit in one line with short hash and message

Key Concept

If you remember nothing else from this pattern, remember: a Git branch is just a file storing the hash of the latest commit it points to.

Common Mistakes

Trying to edit branch files directly without understanding the hash format

Editing branch files incorrectly can corrupt the branch pointer and cause Git errors

Use Git commands like git branch or git reset to safely move branch pointers

Expecting branch files to contain commit messages or file contents

Branch files only store commit hashes, not the commit details or file data

Use git log or git show to view commit details instead

Summary

Initialize a Git repository and create a commit to have a branch pointer.

The branch is stored as a file in .git/refs/heads/ with the commit hash inside.

Use git log and cat on the branch file to see how the branch points to the latest commit.

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