Git Core Concepts

Concept Map

Here's how Git's core concepts connect — from your working directory all the way to the remote repository.

1. Repository

A Git repository is your project folder with a hidden .git/ directory that stores the entire history. There are two ways to get one:

# Create a new repo in the current folder
git init

# Clone an existing repo from a remote
git clone https://github.com/user/repo.git

The .git/ folder contains everything: all commits, branches, tags, and configuration. Delete it and you lose the history — the working files stay, but Git forgets everything.

2. Staging Area (Index)

The staging area is Git's "loading dock" — it sits between your working directory and the repository. You choose exactly which changes to include in the next commit.

# Stage specific files
git add src/app.py tests/test_app.py

# Stage all changes in current directory
git add .

# Unstage a file (keep changes in working directory)
git restore --staged src/app.py

# See what's staged vs unstaged
git status

3. Commits

A commit is an immutable snapshot of your staged changes, plus metadata: author, timestamp, message, and a pointer to the parent commit(s). Each commit has a unique SHA-1 hash (e.g., a1b2c3d).

# Commit staged changes
git commit -m "Fix null pointer in user login"

# Commit with multi-line message
git commit -m "Add password validation

- Minimum 8 characters
- Require at least one number
- Add unit tests for edge cases"

# See commit history
git log --oneline --graph
# a1b2c3d (HEAD -> main) Fix null pointer in user login
# e4f5g6h Add user registration endpoint
# i7j8k9l Initial commit

4. Branches

A branch is just a lightweight pointer to a commit. Creating a branch is instant — Git doesn't copy any files. The default branch is typically called main (or master in older repos).

# Create a new branch
git branch feature/login

# Switch to it (modern syntax)
git switch feature/login

# Create AND switch in one step
git switch -c feature/login

# List all branches (* = current)
git branch
#   feature/login
# * main

# Delete a merged branch
git branch -d feature/login

5. HEAD

HEAD is a pointer to your current position in the repository. Usually it points to a branch name (e.g., HEAD → main → a1b2c3d). When you commit, the branch moves forward and HEAD follows.

# See where HEAD points
git log --oneline -1
# a1b2c3d (HEAD -> main) Fix null pointer

# Detached HEAD — pointing directly at a commit (not a branch)
git checkout a1b2c3d
# You're in "detached HEAD" state — commits here won't belong to any branch

6. Remotes

A remote is a copy of the repository hosted elsewhere (GitHub, GitLab, a server). The default remote is called origin. You sync your local repo with remotes using push, pull, and fetch.

# See configured remotes
git remote -v
# origin  https://github.com/user/repo.git (fetch)
# origin  https://github.com/user/repo.git (push)

# Push local commits to remote
git push origin main

# Fetch remote changes (doesn't merge)
git fetch origin

# Fetch AND merge remote changes
git pull origin main

# Add a new remote
git remote add upstream https://github.com/original/repo.git

7. Merging

Merging combines two branches. Git handles most merges automatically — it only needs human help when the same lines were edited differently on both branches (a merge conflict).

# Merge feature branch into main
git switch main
git merge feature/login
# Fast-forward or merge commit, depending on history

# If there's a conflict:
# 1. Git marks conflicting files
# 2. Edit the files to resolve
# 3. Stage the resolved files
git add src/app.py
# 4. Complete the merge
git commit

A fast-forward merge happens when main hasn't changed since you branched — Git just moves the pointer forward. A merge commit happens when both branches have new commits — Git creates a new commit with two parents.