🔀 Setting Up Git & GitHub

What Is Version Control?

A version control system records the history of your project — every change, who made it, and when — so you can move backward and forward through time. When you accidentally break something, you rewind. When you want to try a risky idea, you branch off safely. When you work with others, everyone's changes merge together without emailing zip files around.

Think about writing a novel. You'd want to save named drafts, jump back to an earlier one, see what changed between them, and maybe co-write with a partner. Git gives your code exactly those powers. It's the most widely used version control system in the world, and knowing it is non-negotiable for any developer.

That four-box flow is the entire mental model of Git. Everything else is detail. We'll come back to it throughout the course, but internalize the direction of the arrows now: you stage changes, commit them into history, then push them up to GitHub to share and back them up.

Git vs GitHub

Beginners mix these up constantly, so let's nail the difference right away.

Installing Git

Step 1 — Check if it's already installed

Open a terminal (Command Prompt or PowerShell on Windows, Terminal on Mac/Linux) and run:

git --version

If you see something like git version 2.44.0, you already have it — skip to configuration. If not, install it below.

# Install Homebrew first if you don't have it:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# Then:
brew install git
git --version

# Ubuntu / Debian
sudo apt update && sudo apt install git

# Fedora
sudo dnf install git

# Arch
sudo pacman -S git

git --version

Configuring Git

Before your first commit, Git needs to know who you are — this identity gets stamped on every commit you make, like a signature. Run these once and they apply to every project on your machine (that's what --global means).

# Your name — appears on every commit
git config --global user.name "Your Name"

# Your email — use the SAME email you'll use for GitHub
git config --global user.email "your.email@example.com"

# Make new repos start on a branch called "main" (the modern default)
git config --global init.defaultBranch main

# Use VS Code for commit messages and merges; --wait pauses Git until you close the tab
git config --global core.editor "code --wait"

# Colorize Git's terminal output for readability
git config --global color.ui auto

Verify your setup

# See everything you've configured
git config --list

# Check a single value
git config user.name

Creating a GitHub Account

GitHub will become your public coding home, so a little care up front pays off.

1. Visit github.com and click Sign up
2. Use the same email as your Git config
3. Pick a professional username — employers will see it, so favor jane-dev over xX_g4m3r_Xx
4. Choose a strong password and complete the verification
5. Select the free plan — it's genuinely all you need
6. Add a photo and short bio; a complete profile looks credible

Connecting With SSH Keys

To push code to GitHub without typing a password every time, you'll use SSH keys. An SSH key is a matched pair: a private key that stays secret on your computer, and a public key you hand to GitHub. GitHub uses the public key to verify requests signed by your private key — cryptographic proof it's really you, no password required.

Step 1 — Check for existing keys

ls -al ~/.ssh

Look for a file ending in .pub such as id_ed25519.pub. If one exists, you can reuse it and skip to Step 4.

Step 2 — Generate a new key

# Ed25519 is the modern, recommended algorithm — use your GitHub email
ssh-keygen -t ed25519 -C "your.email@example.com"

# Only if an old system lacks Ed25519 support:
ssh-keygen -t rsa -b 4096 -C "your.email@example.com"

When prompted:

• Press Enter to accept the default file location
• Optionally set a passphrase — recommended; it's an extra lock on your private key

Step 3 — Add the key to the ssh-agent

# Start the agent (the background helper that holds your key)
eval "$(ssh-agent -s)"

# Add your private key to it
ssh-add ~/.ssh/id_ed25519

Step 4 — Add the PUBLIC key to GitHub

1. Copy your public key to the clipboard:

# macOS
pbcopy < ~/.ssh/id_ed25519.pub

# Linux (needs xclip)
xclip -selection clipboard < ~/.ssh/id_ed25519.pub

# Windows (Git Bash)
clip < ~/.ssh/id_ed25519.pub

# Or just print it and copy manually
cat ~/.ssh/id_ed25519.pub

2. On GitHub: Settings → SSH and GPG keys → New SSH key
3. Give it a descriptive title (e.g. "My Laptop")
4. Paste the key and click Add SSH key

Step 5 — Test the connection

ssh -T git@github.com

Hi your-username! You've successfully authenticated,
but GitHub does not provide shell access.

Your First Repository

A repository (or "repo") is a project folder that Git tracks. Let's create one on GitHub, bring it to your computer, and push a change back.

Create it on GitHub

1. Click the + in the top-right → New repository
2. Name it my-first-repo
3. Add a description: "Learning Git and GitHub"
4. Check Add a README file
5. Choose the MIT License
6. Click Create repository

Clone it to your computer

# Go to where you keep projects
cd ~/Documents

# Clone using the SSH URL (the green Code button → SSH)
git clone git@github.com:YOUR_USERNAME/my-first-repo.git

# Move into the new folder
cd my-first-repo

Make your first commit

# Create a new file
echo "# Hello, Git!" > hello.md

# See what Git noticed
git status

# Stage the file (move it to the staging area)
git add hello.md

# Commit it into history with a clear message
git commit -m "Add hello.md with a greeting"

# Push the commit up to GitHub
git push origin main

Refresh your repo page on GitHub — hello.md is there. You just completed the full loop: edit → add → commit → push. That cycle is 90% of daily Git use.

Essential Git Commands

These are the everyday commands you'll use from day one. You don't need to memorize them cold — they'll stick through repetition.

The .gitignore file

Some files should never be tracked — bulky dependencies, secret keys, OS clutter. A .gitignore file at your project root tells Git to ignore them:

# Dependencies — huge and re-installable, never commit these
node_modules/

# Secrets — API keys and passwords must stay out of Git
.env

# OS-generated junk
.DS_Store
Thumbs.db

# Editor folders
.vscode/
.idea/

# Build outputs
dist/
build/

Practice & Quiz

git clone git@github.com:YOUR_USERNAME/fullstack-course.git
cd fullstack-course

echo "# My Full Stack Journey" > README.md
mkdir notes
echo "# Day 1 Notes: set up VS Code, Git, and GitHub." > notes/day1.md
printf "node_modules/\n.env\n.DS_Store\n" > .gitignore

git add .
git commit -m "Add README, day 1 notes, and gitignore"
git push origin main

Best Practices & Troubleshooting

✅ Do — write good commit messages

A commit message should explain the why, not just the what. Compare:

• ✅ "Fix navigation dropdown not opening on mobile"
• ❌ "Fixed stuff"
• ✅ "Add user authentication with JWT tokens"
• ❌ "Update files"

✅ Do — commit early and often

• Commit after each small, working piece of a feature
• Commit before trying something experimental (an easy point to return to)
• Never commit broken code you know doesn't work

❌ Don't

• Don't commit node_modules/, .env, or secrets — that's what .gitignore is for
• Don't let days of work pile into one giant commit; small commits are easier to understand and undo
• Don't share or paste your private key anywhere, ever

Summary

📚 Additional Resources

• Official Git Documentation & the free Pro Git book
• GitHub Docs — Connecting to GitHub with SSH
• GitHub — Hello World quickstart

🚀 What's Next?

Your environment is fully set up: editor, version control, and a GitHub home for your work. Now the real building begins. The next lesson dives into HTML document structure — the skeleton every web page is built on.