What a Branch Is

Why branches

A branch lets you work on something without disturbing what’s on your main line: try an idea, build a feature, or fix one thing while another is half done. If it works out you merge it in; if not, you delete it ¹.

Git’s branches are famously cheap. To see why, you need to know what one actually is.

A pointer that moves

Every commit points back to its parent. A branch is just a lightweight, movable pointer to one of those commits: a name like main attached to a commit ID ¹. On disk, a branch is a tiny file holding that one ID, which is why creating one is instant ¹.

Git keeps one more special pointer, HEAD, that says which branch you’re on ¹. When you commit, the new commit’s parent is the commit HEAD’s branch points to, and that branch moves forward to the new commit. Other branches stay where they are.

Making and switching branches

me@linuxbox:~/garden$ git branch
* main
me@linuxbox:~/garden$ git switch -c fence
Switched to a new branch 'fence'

git switch -c fence creates a branch named fence at the current commit and switches to it ². Commit on it as usual:

me@linuxbox:~/garden$ echo "cedar posts, 8 ft apart" > fence.txt
me@linuxbox:~/garden$ git add fence.txt && git commit -m "Plan the fence"
me@linuxbox:~/garden$ git switch main
Switched to branch 'main'
me@linuxbox:~/garden$ ls
beds.txt

Switching back to main changes the files in your folder to match that branch: fence.txt disappears, because it doesn’t exist on main yet ¹. It isn’t lost; it’s in the fence branch’s commits.

Commit something on main too, and the history diverges. git log --oneline --graph --all draws it ¹:

me@linuxbox:~/garden$ echo lettuce >> beds.txt && git commit -am "Add lettuce"
me@linuxbox:~/garden$ git log --oneline --graph --all
* e86b128 (HEAD -> main) Add lettuce
| * d595886 (fence) Plan the fence
|/
* 043dfca Plan the beds

The names in parentheses show where each branch points, and HEAD -> main shows which one you’re on. (This is the git lg alias from module 1.)

Switching with uncommitted changes

If you have uncommitted changes when you switch, git carries them along when it safely can. If they’d collide with differences between the two branches, git refuses to switch rather than lose your work ^{1 2}. Commit first, or put the changes aside with git stash (module 5). The habit: commit or stash before switching.

Deleting branches

When a branch has been merged (next lesson) you don’t need its name anymore:

me@linuxbox:~/garden$ git branch -d fence
Deleted branch fence (was d595886).

-d refuses to delete a branch whose commits aren’t merged anywhere; -D forces it, for experiments you’re abandoning ¹. Deleting a branch only deletes the name; merged commits stay in history.

Detached HEAD

You can also switch to a specific commit rather than a branch, to look at the project as it was then: git switch --detach 043dfca ². HEAD then points straight at a commit, with no branch name; git calls this a detached HEAD. Look around all you like. If you make commits there and want to keep them, give them a branch name before you leave: git switch -c rescue.

Your turn

So

A branch is a movable pointer to a commit, and HEAD points to the branch you’re on; committing moves that branch forward. git switch -c creates and switches, git switch changes branches (and your files), git log --oneline --graph --all shows the picture, and git branch -d removes merged branches. Commit or stash before switching.