Git & GitHub for Beginners

1. What is Git?

Git is a distributed version control system (DVCS). It records snapshots of your project over time so you can:

• See exactly what changed, when, and by whom.
• Go back to any previous state.
• Work on several ideas in parallel without breaking the main code.
• Combine work from multiple people.

Git runs entirely on your computer. GitHub is a website that hosts Git repositories and adds collaboration features on top. You can use Git without GitHub, but GitHub is useless without Git.

2. The Three Areas

Almost every confusing thing about Git disappears once you understand that your work lives in three places.

3. First-Time Setup

Install Git, then tell it who you are. This is done once per machine.

# Identity — attached to every commit you make
git config --global user.name "Ada Lovelace"
git config --global user.email "ada@example.com"

# Name the default branch "main" instead of "master"
git config --global init.defaultBranch main

# Nicer output
git config --global color.ui auto
git config --global pull.rebase false

# Verify everything
git config --list

# Where does Git look for settings? (--global = ~/.gitconfig)
git config --list --show-origin

Connecting to GitHub over SSH (recommended)

# 1. Create a key pair
ssh-keygen -t ed25519 -C "ada@example.com"
# Press Enter for the default path, then set a passphrase

# 2. Copy the PUBLIC key
cat ~/.ssh/id_ed25519.pub

# 3. Paste it into GitHub → Settings → SSH and GPG keys → New SSH key

# 4. Test the connection
ssh -T git@github.com

4. Starting a Repo

Option A — Create a brand new repository

mkdir my-project
cd my-project
git init
# Initialized empty Git repository in /path/my-project/.git/

echo "# My Project" > README.md
git add README.md
git commit -m "Initial commit"

Option B — Copy an existing repository

# HTTPS (asks for a token)
git clone https://github.com/octocat/Hello-World.git

# SSH (uses your key)
git clone git@github.com:octocat/Hello-World.git

# Clone into a specific folder name
git clone git@github.com:octocat/Hello-World.git my-folder

# Shallow clone — faster, no full history
git clone --depth 1 git@github.com:octocat/Hello-World.git

git clone does four things: downloads the history, creates a remote named origin pointing at the URL, checks out the default branch, and sets up tracking.

5. The Daily Loop

This is 90% of what you'll ever type:

# 1. See where you are and what's changed
git status

# 2. Look at the actual changes
git diff                 # unstaged changes
git diff --staged        # what's about to be committed

# 3. Stage what you want in the next commit
git add file.txt         # one file
git add src/             # a folder
git add .                # everything in the current dir
git add -p               # choose changes hunk by hunk (very useful)

# 4. Save the snapshot
git commit -m "Add login form validation"

# 5. Send it to GitHub
git push

Reading the log

git log
git log --oneline
git log --oneline --graph --decorate --all
git log -p                     # with full diffs
git log --author="Ada"
git log --since="2 weeks ago"
git log -- src/app.js          # history of one file
git show a1b2c3d               # inspect one commit
git blame src/app.js           # who last touched each line

Writing a good commit message

# Bad
git commit -m "fix stuff"

# Good — imperative mood, explains WHY
git commit -m "Fix crash when email field is empty"

# Better — short subject + blank line + body
git commit -m "Fix crash when email field is empty" \
           -m "The validator assumed a non-null value. Added a guard and
a regression test in tests/validation.test.js."

Convention: subject line ≤ 50 characters, imperative mood ("Add", "Fix", "Remove" — not "Added" or "Fixes").

6. Branching & Merging

A branch is a lightweight, movable pointer to a commit. Creating one costs nothing and takes no time — so create them liberally.

Working with branches

git branch                          # list local branches
git branch -a                       # list local + remote
git branch -v                       # with last commit

git switch -c feature/login         # create AND switch
git switch main                     # go back to main

# Older syntax (still works everywhere)
git checkout -b feature/login
git checkout main

git branch -d feature/login         # delete (safe: only if merged)
git branch -D feature/login         # force delete
git branch -m new-name              # rename current branch

Merging

# Bring feature work into main
git switch main
git merge feature/login

# Two possible outcomes:
#   Fast-forward  → main just slides forward, no merge commit
#   Three-way     → Git creates a merge commit

# Force a merge commit even when fast-forward is possible
git merge --no-ff feature/login

# Undo a merge you haven't pushed
git merge --abort

Merge conflicts

A conflict happens when both branches changed the same lines. Git marks the file and stops:

<<<<<<< HEAD
const timeout = 3000;
=======
const timeout = 5000;
>>>>>>> feature/login

To resolve:

1. Open the file and edit it into the version you want.
2. Delete the <<<<<<<, =======, and >>>>>>> markers.
3. git add <file>
4. git commit (Git pre-fills the merge message).

git status                  # "Unmerged paths" lists conflicted files
git diff                    # shows conflict markers
# ...edit files...
git add .
git commit
# Or bail out entirely:
git merge --abort

Rebase — the alternative to merging

# Replay your branch's commits on top of the latest main
git switch feature/login
git rebase main

# Interactive: reorder, edit, squash, drop commits
git rebase -i HEAD~3

# If it goes wrong
git rebase --abort
git rebase --continue

7. GitHub & Remotes

A remote is a named URL to another copy of the repo. The default name is origin.

# See your remotes
git remote -v

# Add one
git remote add origin git@github.com:ada/my-project.git

# Change where origin points
git remote set-url origin git@github.com:ada/renamed.git

# Remove one
git remote remove origin

Push, fetch, pull

# First push of a new branch: -u sets the upstream tracking link
git push -u origin main
# After that, plain "git push" knows where to go
git push

# Push a different branch
git push origin feature/login

# Delete a remote branch
git push origin --delete feature/login

# Download remote changes WITHOUT touching your files
git fetch
git fetch --all --prune

# Download AND integrate into your current branch
git pull
# git pull = git fetch + git merge (or + git rebase)

# Pull with rebase to keep history linear
git pull --rebase

Fork vs. clone vs. branch

To contribute to a project you don't own: fork it → clone your fork → create a branch → commit → push → open a pull request.

# Keep your fork in sync with the original project
git remote add upstream git@github.com:original-owner/project.git
git fetch upstream
git switch main
git merge upstream/main
git push origin main

8. The Pull Request Flow

A Pull Request (PR) is a GitHub feature, not a Git one. It says: "here's a branch of mine; please review it and merge it into yours."

1. Branch off the latest main.

   git switch main
   git pull
   git switch -c fix/empty-email

2. Commit your work in small, logical chunks.

   git add src/validator.js tests/validator.test.js
   git commit -m "Guard against empty email in validator"

3. Push the branch.

   git push -u origin fix/empty-email

4. Open the PR on GitHub. Fill in what changed and why.
5. Respond to review — push more commits to the same branch; the PR updates automatically.
6. Merge via the GitHub button, then clean up.

   git switch main
   git pull
   git branch -d fix/empty-email

Merge strategies on GitHub

9. Undoing Things

Git almost never loses data — but it helps to know which tool to reach for.

reset vs. revert

• reset moves your branch pointer backwards and erases commits from the branch. Use on local, unpushed work.
• revert creates a new commit that undoes an old one. Use on anything already shared.

Stashing

git stash                       # save & clean working tree
git stash push -m "wip: login"  # with a label
git stash -u                    # include untracked files
git stash list
git stash pop                   # reapply and remove from stash
git stash apply stash@{2}       # reapply but keep in stash
git stash drop stash@{0}
git stash clear                 # delete all stashes

The reflog — your safety net

git reflog
# a1b2c3d HEAD@{0}: commit: Fix typo
# 9f8e7d6 HEAD@{1}: reset: moving to HEAD~1

# Recover the "lost" commit
git switch -c rescue 9f8e7d6
# or
git reset --hard 9f8e7d6

Force pushing, safely

# After amending or rebasing a pushed branch
git push --force-with-lease
# Safer than --force: refuses if someone else pushed in the meantime

10. .gitignore & Good Habits

A .gitignore file at the repo root lists patterns Git should pretend don't exist.

# Dependencies
node_modules/
vendor/

# Build output
dist/
build/
*.min.js

# Environment & secrets — NEVER commit these
.env
.env.local
*.pem

# Editor / OS cruft
.vscode/
.idea/
.DS_Store
Thumbs.db

# Logs
*.log
npm-debug.log*

# Negate: keep this one even though *.log is ignored
!important.log

If you already committed a file you now want ignored

git rm --cached .env          # untrack it, keep it on disk
git rm -r --cached node_modules
echo ".env" >> .gitignore
git commit -m "Stop tracking .env"

Habits worth building

• Commit often, commit small. One logical change per commit.
• Pull before you start. git pull --rebase on main.
• Branch for everything. Never commit straight to main on a shared repo.
• Run git status constantly. It tells you what Git thinks is happening.
• Write messages for future-you, who will have forgotten everything.
• Never commit secrets, large binaries, or node_modules.

11. Command Cheat Sheet

Setup

Create & copy

Inspect

Change

Branch & merge

Share

Undo

12. Common Errors & What They Mean

fatal: not a git repository

You're in a folder that isn't a repo (or a subfolder of one). cd into the project or run git init.

Please tell me who you are

Git needs an identity. Run the git config --global user.name and user.email commands from §3.

Updates were rejected because the remote contains work that you do not have

Someone pushed before you. git pull --rebase, resolve any conflicts, then git push.

CONFLICT (content): Merge conflict in <file>

Two branches changed the same lines. Edit the file, remove the <<< / === / >>> markers, git add, git commit.

Your local changes would be overwritten by merge

You have uncommitted edits that clash. Commit them, or git stash first, then pull, then git stash pop.

detached HEAD

You checked out a specific commit or tag rather than a branch. You can look around, but new commits won't belong to any branch. Fix with git switch main or git switch -c new-branch.

Permission denied (publickey)

GitHub doesn't recognize your SSH key. Check ssh -T git@github.com, make sure your public key is uploaded and your remote URL uses git@github.com:….

remote: Support for password authentication was removed

GitHub no longer accepts account passwords over HTTPS. Use SSH, or a Personal Access Token (PAT) as the password.

13. Glossary

Core concepts

Repository repo

A project tracked by Git — the files plus the entire history in .git/.

Working tree (a.k.a. working directory)

The files as they currently exist on disk, which you edit directly.

Index (a.k.a. staging area, stage, cache)

The middle ground where you assemble the next commit. git add writes here.

Commit

A permanent snapshot of the whole project plus metadata (author, message, parent). Identified by a SHA hash.

SHA (a.k.a. hash, object ID)

The 40-character hex ID of a commit or object, e.g. a1b2c3d…. Usually abbreviated to the first 7–10 characters.

Branch

A movable pointer to a commit. Not a copy of files — just a label. main is the conventional primary branch.

HEAD

A pointer to "where you are right now" — normally the tip of the branch you have checked out.

Detached HEAD

HEAD points directly at a commit instead of a branch. New commits here belong to nothing.

Remote

A named reference to another copy of the repo, usually on a server. The default is origin.

origin

The conventional name of the remote you cloned from. Just a nickname — you can rename it.

upstream

Two meanings: (1) the remote branch your local branch tracks; (2) in forking workflows, the original repo you forked from.

Tracking branch

A local branch linked to a remote branch, so git push and git pull work with no arguments.

Clone

A full local copy of a remote repository, including history.

Fork

A server-side copy of someone else's repo into your own GitHub account.

Merge

Combining the histories of two branches into one.

Fast-forward

A merge where the target branch has no new commits, so Git just slides the pointer forward. No merge commit is created.

Merge conflict

Git can't automatically combine changes because both sides edited the same lines. You resolve it by hand.

Rebase

Replaying your commits on top of another branch to create a linear history. Rewrites commit SHAs.

Cherry-pick

Copying a single commit from one branch onto another.

Stash

A temporary shelf for uncommitted changes, so you can switch context cleanly.

Tag

A permanent label on a specific commit, typically used for releases, e.g. v1.2.0.

Diff

The line-by-line difference between two states of a file.

Hunk

A contiguous block of changed lines inside a diff. git add -p works hunk by hunk.

HEAD~1 / HEAD^

Shorthand for "the commit one step before HEAD". HEAD~3 = three commits back.

Reflog

Git's local log of every place HEAD and branches have pointed. Your recovery tool.

Detached / dirty working tree

"Dirty" means you have uncommitted changes. "Clean" means everything is committed.

.gitignore

A file listing paths Git should never track.

GitHub terms

Pull Request PR

A GitHub request to merge one branch into another, with review and discussion attached. GitLab calls it a Merge Request (MR).

Issue

A GitHub thread for reporting a bug, requesting a feature, or discussing a task.

Review

Feedback on a PR. Reviewers can Comment, Approve, or Request Changes.

Actions

GitHub's built-in CI/CD system. YAML files in .github/workflows/ define automated jobs.

Pages

Free static website hosting straight from a repo.

Release

A tag plus release notes and optional downloadable assets.

Gist

A shareable single-file or snippet repository.

Personal Access Token PAT

A scoped, revocable token used instead of a password over HTTPS.

Protected branch

A branch with rules — e.g. "no direct pushes to main" and "require one approval".

CODEOWNERS

A file that auto-assigns reviewers based on which paths a PR touches.

Idioms & slang you'll hear

"Commit early, commit often"

Frequent small commits beat one giant commit. Easier to review, revert, and understand.

"Atomic commit"

A commit that does exactly one logical thing and leaves the project in a working state.

"Bikeshedding"

Arguing at length about trivial details (naming, formatting) while ignoring the hard problems.

"Nit"

A minor, optional review comment — "nit: this variable name could be clearer". Not a blocker.

"LGTM"

"Looks Good To Me" — approval in review slang.

"WIP"

"Work In Progress" — a branch or PR that isn't ready to merge.

"The golden rule of rebase"

Never rebase commits that have already been pushed and shared.

"Force push with lease"

Using --force-with-lease instead of --force, so you won't clobber a teammate's work.

"Merge hell"

A huge, painful conflict caused by long-lived branches diverging too far from main.

"YOLO merge"

Merging without reading the diff. Don't.

"Blame"

git blame shows which commit last changed each line. It's a diagnostic tool, not an accusation.

"Bisect"

git bisect binary-searches your history to find which commit introduced a bug.

"Clean tree"

git status reports nothing to commit. A nice place to be before switching branches.

"History rewrite"

Changing existing commits — via amend, rebase, or filter-repo. Changes SHAs.

"Squash"

Combining several commits into one, usually right before merging a PR.

"The sacred main branch"

The half-joking idea that main must always be deployable and never receive direct pushes.

"Working on a dirty tree"

Having uncommitted changes while trying to switch branches — a common source of confusion.

14. Acronyms