The Dark Ages

model.py
model_v2.py
model_v2_FINAL.py
model_v2_FINAL_actually_final.py
model_v2_FINAL_actually_final_nipun_edits.py

We've all been this person. Five copies, no idea which is real. Let's fix this.

Enter Git: A Time Machine + Multiverse Engine

Git gives you two superpowers:

1. Time Machine — travel to any point in your project's past
2. Multiverse Engine — experiment in parallel realities without risk

Act 1: Let's feel the pain first.

Switch to terminal — Act 1: mkdir ml-chaos

The Three Areas of Git

You don't save everything at once — you pick what goes into each save point.

The Letter Analogy

The envelope (staging area) lets you choose which changes to include in this commit.

Commits = Video Game Save Points

Think of commits like save points in a video game:

• You save before the boss fight (before a risky change)
• You save after clearing a level (after a feature works)
• If you die, you load the last save (not start the whole game over)

Save 1: "Add data loading"          ← level 1 clear
Save 2: "Add preprocessing"         ← level 2 clear
Save 3: "Try new model architecture" ← boss fight attempt
Save 4: "Fix model bug"             ← boss defeated!

Commit message rule: "If applied, this commit will ___."

Good: "Add data augmentation pipeline"
Bad: "stuff", "fix", "asdfgh"

Demo Break: Acts 2 & 3

Act 2: Create a project, initialize Git

mkdir ml-project && cd ml-project && git init

Act 3: The core rhythm

edit → git status → git diff → git add → git commit

Switch to terminal — Acts 2 & 3

.gitignore — The Bouncer at the Door

Some files should never enter the vault:

# .gitignore — Git will pretend these files don't exist
__pycache__/
*.pyc
.env
data/
*.csv

Create this file first thing in every project.

Time Travel: Loading Old Saves

$ git log --oneline
a1b2c3d Add model training script
f4e5d6c Add data preprocessing
7g8h9i0 Initial commit — add README

Every commit has a unique ID (hash). You can always go back.

Branches: The "What If?" Machine

Want to try a risky experiment? Create a parallel universe.

• Your working code stays perfectly safe on main
• Experiment wildly on feature/new-model
• If it works — merge it back
• If it fails — delete the branch, no harm done

A Branch Is Just a Pointer

A branch is not a copy of your files. It's just a sticky note pointing to a commit.

git checkout -b feature/augmentation   # create + switch
git checkout main                      # switch back

Demo Break: Acts 4, 5, 6

Act 4: Create branches, switch between them

Act 5: Break things, undo them with reset and restore

Act 6: Work on a feature branch

Switch to terminal — Acts 4, 5, 6

Merging: Stitching Timelines Together

Both branches have new commits. Git creates a merge commit with two parents — stitching the timelines together.

git checkout main
git merge feature/augmentation

If the branches edited different files (or different parts of the same file), Git merges automatically. Easy.

But what if both branches edited the same line?

Merge Conflicts: Two People, One Line

When two branches change the same line, Git cannot decide which version to keep. It marks the conflict:

def learning_rate():
<<<<<<< HEAD
    return 0.001    # main branch says 0.001
=======
    return 0.01     # feature branch says 0.01
>>>>>>> feature/augmentation

Git is not broken. It just needs you to decide.

Resolving Conflicts: You Are the Arbiter

Step by step:

1. Open the conflicted file
2. Find the <<<<<<< markers
3. Choose which version to keep (or combine both)
4. Delete the markers
5. Stage and commit

# After resolving — you picked 0.001 and added a comment:
def learning_rate():
    return 0.001    # validated in experiment #42

git add model.py
git commit -m "Resolve learning rate conflict — use validated value"

The golden rule of conflicts: read both versions, understand the intent, then decide.

Demo Break: Acts 7 & 8

Act 7: Merge a feature branch into main

Act 8: Create a conflict, resolve it

Switch to terminal — Acts 7 & 8

git stash: Shoving Mess Under the Bed

You're halfway through a feature. Your teammate says "quick, check the main branch!"

Problem: you can't switch branches with uncommitted changes.
Solution: stash them — shove the mess under the bed.

git stash              # hide all uncommitted changes
git checkout main      # do whatever you need
git checkout feature   # come back
git stash pop          # pull the mess back out

Git vs GitHub: Camera vs YouTube

Everything is local until you explicitly push. Git works perfectly without GitHub.

push & pull: The Teleporter

Only three commands talk to the remote:

git remote add origin https://github.com/user/repo.git
git push -u origin main      # first push: link local to remote
git push                     # subsequent pushes
git pull                     # get latest changes

Think of it as syncing your game saves to the cloud — so you can play on another machine (or your teammate can continue where you left off).

Demo Break: Acts 9 & 10

Act 9: Stash changes, switch branches, pop stash

Act 10: Push to GitHub, clone, pull

Switch to terminal — Acts 9 & 10

Quick Reference