Git

Why Git Knowledge Matters

Git is the universal version control system in modern software development. Whether you are a junior developer or a principal engineer, interviewers expect fluency with Git. Understanding how Git works under the hood separates candidates who merely memorize commands from those who can troubleshoot complex merge conflicts, recover lost work, and design efficient branching strategies for their teams.

Git Internals

Git is fundamentally a content-addressable filesystem. Every piece of data is stored as an object identified by a SHA-1 hash.

Refs are human-readable pointers (branches, tags, HEAD) that resolve to commit SHAs.

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    HEAD(("HEAD")) --> main(["refs/heads/main"])
    main --> C3{{"Commit C3"}}
    C3 --> T3[/"Tree"/]
    C3 --> C2{{"Commit C2"}}
    T3 --> B1[["Blob: README.md"]]
    T3 --> B2[["Blob: app.py"]]
    T3 --> ST[/"Tree: src/"/]
    ST --> B3[["Blob: main.java"]]
    C2 --> T2[/"Tree"/]
    C2 --> C1{{"Commit C1"}}

Core Workflow

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
sequenceDiagram
    participant WD as Working Directory
    participant SA as Staging Area (Index)
    participant LR as Local Repository
    participant RR as Remote Repository

    WD->>SA: git add
    SA->>LR: git commit
    LR->>RR: git push
    RR->>LR: git fetch
    RR->>WD: git pull (fetch + merge)
    LR->>WD: git checkout / git switch

• Working Directory — files on disk you are editing
• Staging Area (Index) — snapshot of what will go into the next commit
• Local Repository — full history stored in .git/
• Remote Repository — shared repo (GitHub, GitLab, Bitbucket)

Essential Commands

Setup and Cloning

git init                                          # Initialize a new repository
git clone https://github.com/user/repo.git        # Clone existing repo
git clone -b develop https://github.com/user/repo.git  # Clone specific branch

Everyday Workflow

git status                                        # Check status
git add src/Main.java                             # Stage specific files
git add -A                                        # Stage all changes
git commit -m "feat: add user authentication"     # Commit with message
git push origin feature/login                     # Push to remote
git pull origin main                              # Pull (fetch + merge)
git fetch origin                                  # Fetch without merging

Branching and Switching

git branch -a                                     # List all branches
git switch -c feature/payment                     # Create and switch to new branch
git checkout -b feature/payment                   # Older syntax equivalent
git switch main                                   # Switch to existing branch
git branch -d feature/payment                     # Delete local branch
git push origin --delete feature/payment          # Delete remote branch

Merging and Rebasing

git switch main && git merge feature/payment      # Merge feature into main
git rebase main                                   # Rebase current branch onto main
git rebase --abort                                # Abort rebase in progress
git rebase --continue                             # Continue after resolving conflicts

Stash and Cherry-Pick

git stash                                         # Stash current changes
git stash push -m "WIP: refactoring auth"         # Stash with a message
git stash list                                    # List stashes
git stash pop                                     # Apply and remove most recent stash
git stash apply stash@{2}                         # Apply specific stash
git cherry-pick abc1234                           # Cherry-pick a commit

Reset and Revert

git reset --soft HEAD~1       # Undo commit, keep changes staged
git reset HEAD~1              # Undo commit, keep changes unstaged (mixed, default)
git reset --hard HEAD~1       # Undo commit, DISCARD all changes
git revert abc1234            # Create new commit that undoes a previous commit

History and Inspection

git log --oneline --graph --all                   # Visual commit log
git diff HEAD~3..HEAD                             # Changes between commits
git diff --cached                                 # Changes in staging area
git blame src/Main.java                           # Who changed each line
git bisect start                                  # Binary search for bug commit
git bisect bad                                    # Mark current as bad
git bisect good v1.0                              # Mark known good commit
git bisect reset                                  # End bisect session

Branching Strategies

Git Flow

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
gitGraph
    commit id: "init"
    branch develop
    checkout develop
    commit id: "feat-1"
    branch feature/login
    commit id: "login-wip"
    commit id: "login-done"
    checkout develop
    merge feature/login
    branch release/1.0
    commit id: "bump-version"
    checkout main
    merge release/1.0 tag: "v1.0"
    checkout develop
    merge release/1.0

GitHub Flow

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
gitGraph
    commit id: "init"
    branch feature/auth
    commit id: "auth-impl"
    commit id: "auth-tests"
    checkout main
    merge feature/auth id: "PR #42"
    commit id: "deploy"

Trunk-Based Development

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
gitGraph
    commit id: "feat-A"
    commit id: "feat-B"
    branch short-lived/fix
    commit id: "fix"
    checkout main
    merge short-lived/fix
    commit id: "feat-C"
    commit id: "feat-D"

Merge vs Rebase

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
gitGraph
    commit id: "A"
    commit id: "B"
    branch feature
    commit id: "C"
    commit id: "D"
    checkout main
    commit id: "E"
    merge feature id: "M (merge commit)"

After rebase instead: commits C and D replay on top of E, producing A - B - E - C' - D' (linear, no merge commit).

Golden Rule: Never rebase commits that have been pushed and shared with others.

Conflict Resolution Workflow

# 1. Attempt merge or rebase
git merge feature/payment

# 2. Check which files conflict
git status

# 3. Resolve conflict markers in files:
#    <<<<<<< HEAD
#    (your changes)
#    =======
#    (their changes)
#    >>>>>>> feature/payment

# 4. Stage resolved files and complete
git add src/Payment.java
git commit                    # for merge
# or: git rebase --continue   # for rebase

Tips: Use git mergetool for visual diffs, git rerere for recurring conflicts, and git diff --check to find leftover markers.

Interactive Rebase

Rewrite commit history before pushing with git rebase -i HEAD~4:

Example — squash WIP commits before PR:

pick abc1234 feat: add payment service
squash def5678 wip: fixing tests
squash ghi9012 wip: more fixes
pick jkl3456 feat: add payment validation

Git Hooks

Scripts in .git/hooks/ that run automatically at key points:

Example pre-commit hook:

#!/bin/sh
if grep -rn "console.log\|debugger\|System.out.println" --include="*.java" --include="*.js" .; then
    echo "ERROR: Debug statements found. Remove before committing."
    exit 1
fi

Use Husky or pre-commit to version-control hooks in your repo.

.gitignore Patterns

# Compiled output
*.class
*.jar
target/
build/

# IDE files
.idea/
.vscode/
*.iml

# OS files
.DS_Store
Thumbs.db

# Environment and secrets
.env
*.pem

# Dependencies
node_modules/
venv/

# Negation — track this specific file
!config/default.env

Pattern rules: * matches anything except /, ** matches directories recursively, ! negates (re-includes), trailing / matches only directories. Debug with git check-ignore -v <file>.

Tips and Advanced Usage

Reflog for Recovery

The reflog records every HEAD change — even after reset --hard:

git reflog                              # View reflog
git branch recovered-work abc1234       # Recover a "lost" commit

Entries expire after 90 days by default.

Worktrees

Check out multiple branches simultaneously in separate directories:

git worktree add ../hotfix-dir hotfix/critical-bug
git worktree list
git worktree remove ../hotfix-dir

Useful Aliases

git config --global alias.st "status -sb"
git config --global alias.lg "log --oneline --graph --all --decorate"
git config --global alias.unstage "restore --staged"
git config --global alias.last "log -1 HEAD --stat"

Interview Questions

git reflog
git branch recovery-branch abc1234