🚀 Version Control & Branching: The Time Machine for Your Code

Imagine you’re building the world’s greatest LEGO castle. You’ve been working on it for weeks. Then your little brother accidentally knocks it over! 😱

What if you had a magic camera that took pictures every time you added a piece? You could rebuild it exactly! That’s what version control does for code.

🎯 What is Version Control?

Think of version control like a time machine + photo album for your code.

Simple Example:

• You write a story about a dragon 🐉
• You save “Dragon Story v1”
• You change the dragon to a unicorn 🦄
• You save “Dragon Story v2”
• Oops! The dragon was better!
• You can go back to v1 instantly!

Real Life:

• Google Docs showing “Version History” = version control idea
• “Undo” button in any app = simple version control
• Git = the super-powered version control for programmers

Why Do We Need It?

🌳 Branch Types: Parallel Universes for Your Code

Imagine you’re writing a choose-your-own-adventure book. In one path, the hero fights a dragon. In another, they befriend the dragon. Both stories exist at the same time!

Branches are parallel universes for your code.

graph TD
    A[main branch] --> B[Your stable code]
    A --> C[feature/dragon-fight]
    A --> D[feature/dragon-friend]
    C --> E[Merge winner back!]
    D --> E

Common Branch Types

Example:

main           ━━━━━━━━━━━━━━━━━━━━━━━━━━━
                    ↘         ↗
feature/shop   ━━━━━━━━━━━━━━━

🏷️ Git Tagging: Putting Flags on Important Moments

Remember when you beat the final boss in a video game? You’d want to save that moment forever, right?

Tags are like saving your game at important moments.

Two Types of Tags

Lightweight Tag (simple bookmark):

git tag v1.0

Annotated Tag (bookmark with a note):

git tag -a v1.0 -m "First release!"

When to Use Tags

Real Example:

# See all your tags
git tag

# Tag the current moment
git tag -a v1.0.0 -m "Launch day!"

# Push tags to share with team
git push origin --tags

🎣 Git Hooks: Automatic Robot Helpers

Imagine having a robot assistant that checks your homework before you turn it in. “Wait! You forgot to write your name!”

Git hooks are robot helpers that run automatically.

How It Works

graph TD
    A[You try to commit] --> B{pre-commit hook}
    B -->|Tests pass| C[Commit saved!]
    B -->|Tests fail| D[Blocked! Fix it first]

Common Hooks

Example pre-commit hook:

#!/bin/sh
# Runs before every commit

# Check for "TODO" left in code
if grep -r "TODO" src/; then
  echo "Remove TODOs first!"
  exit 1
fi

echo "All good! Committing..."

🔢 Semantic Versioning: Speaking the Same Language

When your favorite game updates from “Version 2.1.3” to “Version 3.0.0”, what does that mean?

Semantic versioning is a universal code for updates.

The Magic Formula: MAJOR.MINOR.PATCH

   2  .  1  .  3
   │     │     │
   │     │     └── PATCH: Fixed small bugs
   │     └──────── MINOR: Added new features
   └────────────── MAJOR: Big changes (might break things!)

What Each Number Means

Real World Example:

v1.0.0  → First release! 🎉
v1.0.1  → Fixed login bug
v1.1.0  → Added dark mode
v1.2.0  → Added profile pictures
v2.0.0  → Complete redesign (old plugins may break!)

🌲 Trunk-Based Development: One Tree, Many Leaves

Imagine a big oak tree. All branches grow from one strong trunk. They don’t stay separate forever—they’re always connected to the main tree.

Trunk-based development = everyone works close to the main code.

The Rules

1. Keep branches SHORT (hours or days, not weeks)
2. Merge to main OFTEN (at least daily)
3. Main is ALWAYS working (never broken)

graph TD
    A[main trunk] --> B[tiny feature 1]
    A --> C[tiny feature 2]
    B --> A
    C --> A
    A --> D[tiny feature 3]
    D --> A

Compare the Approaches

Example Day:

# Morning: Start small feature
git checkout -b feature/add-button

# Afternoon: Done! Merge back
git checkout main
git merge feature/add-button

# Branch lived: 4 hours ✅

🌊 GitHub Flow: The Simple Path

GitHub Flow is like a simple recipe for cooking. Easy to follow, hard to mess up!

The 6 Steps

graph TD
    A[1. Create branch from main] --> B[2. Add your changes]
    B --> C[3. Open Pull Request]
    C --> D[4. Team reviews code]
    D --> E[5. Merge to main]
    E --> F[6. Deploy immediately!]

Step by Step

Real Example:

# Step 1: Branch from main
git checkout main
git pull
git checkout -b feature/dark-mode

# Step 2: Make changes
# ... write code ...
git add .
git commit -m "Add dark mode toggle"

# Step 3: Push and create PR
git push -u origin feature/dark-mode
# Then open PR on GitHub website

🔀 Merge Strategies: Ways to Combine Code

When two people write different chapters of a book, how do you combine them into one book?

There are different strategies for merging code.

The Three Main Strategies

1. Merge Commit (The Family Photo)

Everyone’s history is kept. Like a family photo showing everyone together.

main:    A---B-------M
              \     /
feature:       C---D

git checkout main
git merge feature/new-thing

2. Squash Merge (The Summary)

Combine all changes into one neat commit. Like writing a summary of a whole chapter.

main:    A---B---S (S = squashed C+D)
              \
feature:       C---D

git checkout main
git merge --squash feature/new-thing
git commit -m "Add new feature"

3. Rebase (The Clean Timeline)

Replay your changes on top. Like rewriting history to look cleaner.

Before:  A---B (main)
              \
               C---D (feature)

After:   A---B---C'---D' (feature rebased)

git checkout feature/new-thing
git rebase main

When to Use Each

🎯 Quick Summary

🌟 You Did It!

You now understand how developers:

• ✅ Track every change with version control
• ✅ Work on features without breaking things (branches)
• ✅ Mark important releases (tags)
• ✅ Automate quality checks (hooks)
• ✅ Communicate changes clearly (semantic versioning)
• ✅ Stay organized with workflows (trunk-based, GitHub Flow)
• ✅ Combine work smoothly (merge strategies)

Next time you see “v2.0.0” or “merge pull request”, you’ll know exactly what’s happening! 🎉