Mastering Version Control: A Complete Guide to Git for Developers

# See all previous versions
git log --oneline

# Compare today with last week
git diff HEAD~7

# Go back to any version
git checkout abc123

git blame payment.js

# Output:
# abc123 (Piyush  2025-12-10) function processPayment() {
# def456 (Hitesh  2025-12-11)   if (amount > 0) {

# Set your name (appears in commits)
git config --global user.name "Your Name"

# Set your email (appears in commits)
git config --global user.email "your.email@company.com"

# Set default branch name to 'main'
git config --global init.defaultBranch main

# Verify your settings
git config --list

On GitHub, navigate to the main page of the repository.

Above the list of files, click  Code.

To clone the repository using HTTPS, under "HTTPS", 
click on copy icon.

To clone the repository using an SSH key, including 
a certificate issued by your organization's 
SSH certificate authority, click SSH, then click on copy icon.

To clone a repository using GitHub CLI, click GitHub CLI, 
then click on copy icon.

Change the current working directory to the location 
where you want the cloned repository.

Type git clone, and then paste the URL you copied earlier.

git clone https://github.com/USERNAME/REPOSITORY-NAME.git
Press Enter to create your local clone.

$ git clone https://github.com/USERNAME/REPOSITORY-NAME.git
> Cloning into `Spoon-Knife`...
> remote: Counting objects: 10, done.
> remote: Compressing objects: 100% (8/8), done.
> remove: Total 10 (delta 1), reused 10 (delta 1)
> Unpacking objects: 100% (10/10), done.

This creates:
project-name/
  ├── all project files
  └── .git/          ← Complete history lives here

# View the .git folder structure
ls -la .git/

# Output:
.git/
  ├── HEAD              ← "You Are Here" marker
  ├── config            ← Repository settings
  ├── refs/
  │   ├── heads/        ← Local branch pointers
  │   │   └── main      ← Just a text file!
  │   └── remotes/      ← Remote branch pointers
  ├── objects/          ← All your files and commits (compressed)
  └── logs/             ← Reflog (your safety net)

# See what HEAD contains
cat .git/HEAD
# Output: ref: refs/heads/main

# See what the 'main' branch points to
cat .git/refs/heads/main
# Output: a1b2c3d4e5f6g7h8i9j0... (40-character commit hash)

┌──────────────────────────────────────────────────┐
│            LOCAL REPOSITORY STRUCTURE            │
└──────────────────────────────────────────────────┘

  📁 my-project/
  │
  ├── 📄 index.html           ┐
  ├── 📄 style.css            ├── Your working files (visible)
  ├── 📄 app.js               ┘
  │
  └── 📁 .git/                     ← HIDDEN FOLDER (all the magic)
      │
      ├── HEAD                     ← "You are on: main"
      │   └─→ refs/heads/main
      │
      ├── refs/heads/
      │   ├── main → abc123        ← Branch pointer (text file)
      │   └── feature → def456     ← Another branch
      │
      ├── objects/
      │   ├── ab/c123...           ← Commit objects
      │   ├── de/f456...           ← Tree objects (folders)
      │   └── 12/3abc...           ← Blob objects (file contents)
      │
      └── logs/
          └── HEAD                 ← Reflog: everywhere HEAD has been

HEAD ──→ refs/heads/main ──→ Commit abc123
         (branch name)       (actual commit)

Before:
HEAD ──▶ main ──▶ C ──▶ B ──▶ A

After:
HEAD ──▶ main ──▶ D ──▶ C ──▶ B ──▶ A

git checkout abc123    # A specific commit, not a branch name

HEAD ──→ Commit abc123
         (no branch involved!)

Before (on main):
HEAD → main → C    (where A ← B ← C is the history)

You checkout commit B (detached):

       main → C
              ↑
        A ← B ← C
            ↑
          HEAD (detached - pointing directly to B)

You make a new commit D while detached:

       main → C
              ↑
        A ← B ← C
            ↑
            D ← HEAD

You switch back to main:

       main → C ← HEAD
              ↑
        A ← B ← C
            ↑
            D (ORPHANED! No branch points to it)

Where is D? It has NO REFERENCE pointing to it!

main ──→ C ──→ B ──→ A ──→ (initial)
         │     │     │
       parent parent parent

Reachability Check:
┌─────────────────────────────────────────────────────────────────┐
│  main → C → B → A                                               │
│         ✓   ✓   ✓   All reachable from main = PROTECTED        │
│                                                                 │
│  Orphan commit D (from detached HEAD)                           │
│         ✗   No branch or tag points to it = WILL BE DELETED    │
└─────────────────────────────────────────────────────────────────┘

git reflog

# Output:
e4f5g6h HEAD@{0}: checkout: moving from detached to main
d123456 HEAD@{1}: commit: my orphan commit        ← Still recoverable!
abc123  HEAD@{2}: checkout: moving from main to abc123

# Find the orphan commit hash in reflog
git reflog

# Create a branch to save it
git branch rescue-my-work d123456

# Now it's protected!

You are in 'detached HEAD' state...

git checkout -b my-new-branch
# Now you're safe—a branch protects your commits

git checkout main
# Warning: Any commits you made while detached may be lost!

# First, make sure you have the latest main
git checkout main
git pull origin main

# Create AND switch to a new branch
git checkout -b feature/user-authentication

# Or the modern way (Git 2.23+)
git switch -c feature/user-authentication

main:        ──●──●──●──●─────────────────●── (stable, production-ready)
                    \                     /
your-feature:        ●──●──●──●──●──●────     (your work, isolated)

# You're on your feature branch
git branch
#   main
# * feature/login-page

<!-- login.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    <h1>Login to Your Account</h1>
    <form>
        <input type="email" placeholder="Email" />
        <input type="password" placeholder="Password" />
        <button type="submit">Login</button>
    </form>
</body>
</html>

git status

# Output:
On branch feature/login-page
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        login.html

nothing added to commit but untracked files present

git add login.html

git status

# Output:
On branch feature/login-page
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   login.html

git commit -m "feat: add basic login page structure"

# Output:
[feature/login-page 3f2a1b9] feat: add basic login page structure
 1 file changed, 14 insertions(+)
 create mode 100644 login.html

<!-- login.html (modified) -->
<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
    <link rel="stylesheet" href="login.css">   <!-- NEW LINE -->
</head>
<body>
    <h1>Login to Your Account</h1>
    <form>
        <input type="email" placeholder="Email" />
        <input type="password" placeholder="Password" />
        <button type="submit">Login</button>
    </form>
</body>
</html>

/* login.css */
body {
    font-family: Arial, sans-serif;
    display: flex;
    justify-content: center;
    padding-top: 100px;
}

button {
    background: #007bff;
    color: white;
    padding: 10px 20px;
    border: none;
    cursor: pointer;
}

git status

# Output:
On branch feature/login-page
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
        modified:   login.html

Untracked files:
        login.css

git diff login.html

# Output:
diff --git a/login.html b/login.html
index 3f2a1b9..8c4d2e1 100644
--- a/login.html
+++ b/login.html
@@ -3,6 +3,7 @@
 <head>
     <title>Login</title>
+    <link rel="stylesheet" href="login.css">
 </head>

# Stage both files
git add login.html login.css

git status

# Output:
On branch feature/login-page
Changes to be committed:
        modified:   login.html
        new file:   login.css

# Commit
git commit -m "style: add CSS styling to login page"

# Output:
[feature/login-page 7d4e2f3] style: add CSS styling to login page
 2 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 login.css

git log --oneline -3

# Output:
7d4e2f3 (HEAD -> feature/login-page) style: add CSS styling to login page
3f2a1b9 feat: add basic login page structure
9abc123 (origin/main, main) Previous commit on main

git status

# Output shows:
# - Modified files (changed but not staged)
# - Staged files (ready to commit)
# - Untracked files (new files Git doesn't know about)

git status -s

# Output:
#  M src/App.js          # Modified, not staged
# M  src/index.js        # Modified and staged
# ?? src/NewFile.js      # Untracked
# A  src/AddedFile.js    # New file, staged

# Stage specific file (when you want precise control)
git add src/login.js

# Stage multiple files
git add src/login.js src/auth.js

# Stage all changes in current directory
git add .

# Stage part of a file (interactive—powerful!)
git add -p src/login.js

git add -p src/user.js
# Git shows each change and asks:
# y = stage this chunk
# n = don't stage this chunk
# s = split into smaller chunks
# q = quit

# See unstaged changes
git diff

# See staged changes (what will be committed)
git diff --staged

# Output shows:
# - lines (deleted)
# + lines (added)

git commit -m "feat: add user login form validation"

# ❌ BAD - tells nothing
git commit -m "fixed stuff"
git commit -m "update"
git commit -m "wip"

# ✅ GOOD - clear and searchable
git commit -m "fix: resolve login timeout on slow connections"
git commit -m "feat: add dark mode toggle to settings"
git commit -m "docs: update API authentication examples"

# Save your work temporarily
git stash push -m "WIP: login form halfway done"

# Your working directory is now clean
git switch main
# ... fix the bug, commit, push ...

# Return to your feature
git switch feature/user-authentication

# Restore your work
git stash pop

# Your half-done work is back!

# See commit history
git log

# Compact one-line format
git log --oneline

# Last 5 commits with graph
git log --oneline --graph -5

# History of specific file
git log -- src/login.js

# 1. Switch to main and get latest
git checkout main
git pull origin main

# 2. Switch back to your branch
git checkout feature/user-authentication

# 3. Rebase onto main
git rebase main

BEFORE REBASE:
                 (main moved forward while you worked)
                              ↓
main:       A ── B ── C ── D
                 ↑
                 └── E ── F  ← your-branch (branched from B)

AFTER REBASE:
main:       A ── B ── C ── D
                           ↑
                           └── E' ── F'  ← your-branch

Your commits E and F are "replayed" on top of D (latest main).
E' and F' are NEW commits with different hashes but same changes.

# Git stops and shows conflicted files
git status

# 1. Open each conflicted file
# 2. Look for conflict markers:
<<<<<<< HEAD
code from main
=======
your code
>>>>>>> your-commit

# 3. Edit to keep what you want, remove markers
# 4. Stage the resolved file
git add resolved-file.js

# 5. Continue rebase
git rebase --continue

# While on your feature branch
git merge main

BEFORE MERGE:
                 (main moved forward while you worked)
                              ↓
main:       A ── B ── C ── D
                 ↑
                 └── E ── F  ← your-branch (branched from B)

AFTER MERGE (you run 'git merge main' on your branch):

main:       A ── B ── C ── D ─────────────────┐
                 ↑                            ↓
                 └── E ── F ────────────── M ← your-branch
                                      (merge commit)

M is a "merge commit" with TWO parents: F (your work) and D (main).
This creates a "diamond" or "bubble" in history.

# First-time push (sets upstream tracking)
git push -u origin feature/user-authentication

# Subsequent pushes
git push

git push --force-with-lease origin feature/user-authentication

YOUR PR COMMITS:
E: "feat: add login form"
F: "fix: typo in label"
G: "style: adjust button padding"
H: "fix: forgot validation"

AFTER SQUASH:
S: "feat: add user authentication (#123)"

All your messy WIP commits become one clean commit on main.

# Switch to main
git checkout main

# Get the merged changes
git pull origin main

# Delete local feature branch (it's merged, you don't need it)
git branch -d feature/user-authentication

# Delete remote feature branch (optional, GitHub can auto-delete)
git push origin --delete feature/user-authentication

git reflog

# Output:
e4f5g6h HEAD@{0}: reset: moving to HEAD~3
a1b2c3d HEAD@{1}: commit: my important work    ← "deleted" commit is here!
9876543 HEAD@{2}: commit: previous work

# Find the commit hash in reflog
git reflog

# Reset to that point
git reset --hard a1b2c3d

# Your work is back!

# ─────────────────────────────────────────────────────────────
# UNSTAGE A FILE (after git add, before commit)
# ─────────────────────────────────────────────────────────────
git reset <file>
# or (Git 2.23+)
git restore --staged <file>

# ─────────────────────────────────────────────────────────────
# DISCARD CHANGES IN A FILE (before staging)
# ─────────────────────────────────────────────────────────────
git checkout -- <file>
# or (Git 2.23+)
git restore <file>

# ─────────────────────────────────────────────────────────────
# UNDO LAST COMMIT (keep changes staged)
# ─────────────────────────────────────────────────────────────
git reset --soft HEAD~1

# ─────────────────────────────────────────────────────────────
# UNDO LAST COMMIT (keep changes unstaged)
# ─────────────────────────────────────────────────────────────
git reset HEAD~1

# ─────────────────────────────────────────────────────────────
# UNDO LAST COMMIT (DELETE changes completely) ⚠️
# ─────────────────────────────────────────────────────────────
git reset --hard HEAD~1

# ─────────────────────────────────────────────────────────────
# UNDO A PUSHED COMMIT (safe - creates "undo" commit)
# ─────────────────────────────────────────────────────────────
git revert <commit-hash>

# ─────────────────────────────────────────────────────────────
# RECOVER "LOST" COMMITS
# ─────────────────────────────────────────────────────────────
git reflog
git reset --hard <commit-from-reflog>

                    Moves HEAD?   Clears Staging?   Clears Working Dir?
--soft                 ✓              ✗                   ✗
--mixed (default)      ✓              ✓                   ✗
--hard                 ✓              ✓                   ✓  ⚠️ DANGEROUS

# You're on main but should be on feature branch
# You just committed here by mistake

# 1. Create the correct branch (with your commit)
git branch correct-branch

# 2. Reset main back to before your commit
git reset --hard HEAD~1

# 3. Switch to correct branch
git checkout correct-branch

# Your commit is now on the correct branch!

# Option 1: Stash (if you want to keep changes)
git stash push -m "WIP: description"
git checkout other-branch
# ... do work ...
git checkout original-branch
git stash pop

# Option 2: Commit (if changes are ready)
git add .
git commit -m "WIP: save progress"
git checkout other-branch

# You see: "You are in 'detached HEAD' state"

# If you want to keep working here, create a branch:
git checkout -b my-new-branch

# If you want to go back to a branch:
git checkout main

# Option 1: Incremental rebase (less overwhelming)
git rebase main
# Resolve conflicts one commit at a time

# Option 2: Squash your commits first, then rebase
git rebase -i HEAD~10    # Squash your 10 commits into 1
git rebase main          # Now only 1 commit to conflict-resolve

git status                    # What's changed?
git add .                     # Stage all
git commit -m "message"       # Save snapshot
git push                      # Upload to remote
git pull                      # Download and merge
git log --oneline -10         # Recent history

git branch                    # List branches
git checkout -b new-branch    # Create and switch
git checkout main             # Switch to main
git merge feature-branch      # Merge into current
git branch -d old-branch      # Delete branch

git fetch origin              # Download without merging
git pull origin main          # Download and merge
git rebase main               # Replay commits on main
git push -u origin branch     # First push with tracking
git push --force-with-lease   # Force push (after rebase)

git restore <file>            # Discard unstaged changes
git restore --staged <file>   # Unstage
git reset --soft HEAD~1       # Undo commit, keep staged
git reset HEAD~1              # Undo commit, unstage
git reset --hard HEAD~1       # Undo and delete ⚠️
git revert <commit>           # Create undo commit
git reflog                    # Find lost commits

git stash                     # Save temporarily
git stash pop                 # Restore and delete
git stash list                # Show all stashes