Git & Version Control

A .gitignore file is a list of files and folders that Git should completely ignore. It's like telling Git 'pretend these don't exist.

Git blame shows you who wrote each line of a file and when.

A branch is like creating a parallel universe for your code.

A branch cemetery is the graveyard of abandoned feature branches in your repo. Hundreds of them. Nobody knows what's on them. Nobody dares delete them.

Checkout is like teleporting to a different branch or going back in time to an old version.

Cherry-pick is like copying one specific change from another branch without merging everything.

Clone is like downloading someone's entire project to your computer — all the files, all the history, everything.

A commit is like pressing the save button in a video game.

A conflict is when two people changed the exact same part of the same file differently, and Git doesn't know which version to keep.

Conventional Commits is a format for writing commit messages that humans AND machines can understand.

A dead branch is a branch nobody touches anymore. No commits in months, no open PR, no clear purpose. It's just... there. Safe to delete? Probably.

A diff shows you exactly what changed between two versions of your code.

A fork is like making your own personal copy of someone else's project on GitHub.

Git is like a magical save system for your code. Every time you save (commit), it remembers exactly what changed.

Git blame driven development is when you look at broken code and your first action isn't to fix it — it's to run `git blame` to find out who wrote it.

GitHub is like Instagram for code.

HEAD is like a bookmark that says 'you are here' in your Git history. It points to the commit you're currently looking at.

Git log is like a diary of everything that happened in your project. It shows a timeline of all commits — who made them, when, and the messages they wrote.

Merge is like combining two parallel universes back into one. You take the changes from your branch and smoosh them into another branch.

Merge hell is when you've been on a feature branch for three weeks, main has moved 400 commits, and now every file has a conflict.

A merge monster is that one colossal PR that's been open for two months, touches 400 files, and everyone's afraid to merge.

Origin is just the default nickname for the remote server where your code lives. When you clone a repo, Git automatically names that remote 'origin'.

Pull is the opposite of push — it downloads everyone else's latest changes from the cloud to your computer.

A pull request is like raising your hand in class and saying 'Hey, I made some changes — can someone check my work before we make it official?

Push is like uploading your saved game to the cloud so your friends can download it.

Rebase is like rewriting history.

A remote is the cloud copy of your project — usually on GitHub or GitLab.

A repository (repo) is a folder that Git is watching. It contains all your project files plus the entire history of every change ever made.

Reset is like pressing undo on your commits.

Revert is the safe undo button. Instead of erasing history (like reset), it creates a NEW commit that undoes the changes from an old commit.

Sparse checkout lets you clone only specific folders from a repo — grocery shopping with a list instead of buying the whole store.

Squash is like combining multiple save points into one.

The staging area is like a shopping cart. Before you 'buy' (commit) your changes, you put them in the cart first with `git add`.

A stale branch is one that's fallen behind main so much that merging it back in is going to hurt. A branch goes stale in hours on fast-moving teams.

Stash is like putting your messy work in a drawer temporarily.

A submodule is a repo inside another repo. It's like embedding someone else's project inside yours.

A tag is like a permanent bookmark on a specific commit. While branches move forward as you add commits, a tag stays put forever.

Instead of giant feature branches that live for 3 weeks and cause merge hell, trunk-based development has everyone commit to main every day.

A worktree lets you have multiple branches checked out at the same time in different folders.

A zombie branch is a merged branch that's still lying around in your repo, refusing to stay dead. It got merged weeks ago. The PR is closed.

A zombie PR is one that's technically still open but the author left the company six months ago, the branch conflicts with everything, and the feature was...