Git and GitHub

Learn the fundamentals of version control and understand how Git differs from GitHub.

Git and GitHub are different

Git is a version control system used to track changes to your files. It is free, open-source, and available for Windows, macOS, and Linux. Git is installed as software directly on your computer.

GitHub is a web-based hosting platform for Git repositories. It allows you to store and share code with others online. While GitHub is the most popular provider, alternatives include Gitlab, Bitbucket and Azure Repos.

Version Control Systems

Version control systems manage the history of your code. Think of them as checkpoints in a video game — you can move to any point in history and always go back to a previous checkpoint.

Before Git became mainstream, systems like SCCS (Source Code Control System) were used, but they were proprietary and expensive. Git was created to replace them. Other version control systems include Subversion (SVN), CVS, and Perforce.

Install Git

Download Git from the official website or use your system's package manager:

# macOS (via Homebrew)
brew install git

# Ubuntu / Debian
sudo apt-get install git

# Windows — download from:
# https://git-scm.com/downloads

Verify your installation:

git --version
# git version 2.43.0

Account on GitHub

Create a free account at github.com. You'll need it later when we set up SSH keys to push code to remote repositories. Password authentication is no longer recommended — SSH key authentication is the standard.

Terminology

Git uses its own vocabulary. Here's what every term means and how to use the key commands.

Repository

A repository (repo) is a folder tracked by Git. It's not just storage — it maintains a full history of every change. Any folder can become a repo:

git init          # Initialize a new repo (creates .git/ folder)
git status        # Check the current state of your repo

Config Settings

Every commit records who made it. Set your identity globally:

git config --global user.email "you@example.com"
git config --global user.name "Your Name"
git config --list   # View all settings

The Complete Git Flow

The typical workflow from creating a file to pushing it to GitHub:

Stage

Staging tells Git which changes to include in the next commit. Files in the staging area are ready to be committed but not yet saved permanently:

git add index.html          # Stage a single file
git add .                   # Stage all changes
git status                  # See staged vs unstaged files

Commit

A commit is a permanent snapshot of your staged changes. Each commit gets a unique hash ID.

git commit -m "Add homepage layout"
git log           # Full commit history
git log --oneline # Compact one-line view

Atomic Commits

Each commit should be a single, self-contained unit of work. This makes it easy to revert specific changes without breaking other things. A good commit message is: feat: add user authentication — not changes.

.gitignore

The .gitignore file lists files and folders that Git should never track:

node_modules/
.env
.vscode/
dist/
*.log

Git Behind the Scenes

How Git internally stores every change — snapshots, objects and hash codes.

Git Snapshots

Every time you commit, Git doesn't just record diffs — it stores a full snapshot of your project as it exists at that moment. Each snapshot is identified by a SHA-1 hash — a 40-character string uniquely identifying the contents.

This snapshot system is backed by a key-value object database inside the .git/ folder. There are three core object types.

The 3 Musketeers of Git

Exploring Internals

You can inspect Git's objects directly with these plumbing commands:

# View raw commit data
git show -s --pretty=raw <commit-hash>

# List files in a tree object
git ls-tree <tree-id>

# View a blob's content
git show <blob-id>

# Pretty-print any object
git cat-file -p <object-id>

Branches in Git

Work on multiple features simultaneously without affecting the main codebase.

What is a Branch?

A branch is an independent line of development. Multiple developers can work on different features in parallel — one on a header, another on a footer, another on auth — without stepping on each other's code.

HEAD in Git

HEAD is a special pointer that always points to your current branch's latest commit. When you switch branches, HEAD moves with you. The default branch is now called main (previously master) — it's just a convention, nothing special.

Branch Commands

Merging Branches

Merging brings changes from one branch into another. Git has two merge strategies:

Fast-Forward Merge

Used when the target branch has no new commits since the feature branch was created. Git simply moves the pointer forward — no merge commit needed.

git checkout main
git merge bug-fix      # Fast-forward: no conflicts, clean history

3-Way Merge

Used when both branches have diverged (both have new commits). Git looks at 3 commits: the common ancestor + the tip of each branch, then creates a new merge commit.

Conflicts arise when both branches modified the same lines. You must manually resolve them — there are no shortcuts.

Managing Conflicts

Conflict resolution isn't scary — it's about communication with your team. When Git marks a conflict, it looks like this:

Choose which version to keep (or combine them), then git add the resolved file and commit.

Diff, Stash and Tags

Powerful but often overlooked commands for debugging, context-switching and release management.

Git Diff

git diff compares different versions of files. Git treats the before and after as two separate files and highlights exactly what changed:

Git Stash

Stash is a temporary clipboard for uncommitted work. When you need to switch branches but aren't ready to commit, stash saves your changes to a stack:

git stash                              # Save changes to stash
git stash save "WIP: login feature"   # Save with a name
git stash list                        # View all stashes
git stash apply                       # Apply most recent stash
git stash apply stash@{0}             # Apply specific stash
git stash pop                         # Apply + remove from list
git stash drop                        # Remove most recent stash
git stash clear                       # Remove all stashes

Git Tags

Tags are permanent bookmarks on specific commits — ideal for marking release versions like v1.0.0. Unlike branches, tags don't move when new commits are added.

Lightweight vs Annotated Tags

# Lightweight tag (just a pointer)
git tag v1.0.0

# Annotated tag (stores metadata — preferred for releases)
git tag -a v1.0.0 -m "Release version 1.0.0"

# Tag a specific commit
git tag v0.9.0 <commit-hash>

# List all tags
git tag

# Push tags to remote
git push origin v1.0.0
git push origin --tags     # Push all tags

# Delete a tag
git tag -d v1.0.0
git push origin :v1.0.0    # Delete from remote

Managing History

Keep your project history clean with rebase, and recover anything with reflog.

Merge Commits

A merge commit is automatically created during a 3-way merge. It has two parents and preserves the full history of both branches. This results in a non-linear history that explicitly shows when and where branches were merged.

Rebase in Git

Rebase rewrites commit history by replaying your branch's commits on top of another branch. The result is a clean, linear history — as if you had started your feature branch from the latest commit on main.

# Switch to your feature branch
git checkout feature-branch

# Rebase onto main (replay your commits on top of main)
git rebase main

# If conflicts arise, resolve them, then:
git add <resolved-files>
git rebase --continue

# To abort the rebase entirely:
git rebase --abort

Git Reflog

Reflog is your safety net. It records every movement of HEAD — even actions that aren't in regular git log output, like resets and rebases. This means you can recover almost anything.

# View the full reflog
git reflog

# Example output:
# a3f8d21 HEAD@{0}: commit: add dark mode
# b9c1e45 HEAD@{1}: rebase (finish): refs/heads/feature
# c2d7f90 HEAD@{2}: checkout: moving from main to feature

# Recover a lost commit or branch
git reset --hard <commit-hash>
# or using HEAD reference:
git reset --hard HEAD@{2}

Collaborate with GitHub

Push your code to the cloud, set up SSH authentication, and collaborate with your team.

What is GitHub?

GitHub is a web-based Git repository hosting service — the most popular platform for open-source and team development. Alternatives include GitLab Bitbucket Azure Repos Gitea, but GitHub dominates the ecosystem.

Configuring Git

git config --global user.email "you@example.com"
git config --global user.name "Your Name"
git config --list

Setup SSH Key

Password authentication is deprecated. SSH keys are the secure, recommended way to authenticate with GitHub:

ssh-keygen -t ed25519 -C "you@example.com"

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Publish Code to Remote

# 1. Initialize and commit locally
git init
git add .
git commit -m "Initial commit"

# 2. Add remote repository
git remote add origin git@github.com:username/repo.git

# 3. Check your remote
git remote -v

# 4. Push and set upstream (first time)
git push -u origin main

# After that, just:
git push

Getting Code from Remote

Command Cheatsheet

All the essential Git commands in one place.

Setup

git --version
git config --global user.name "Name"
git config --global user.email "email"
git config --global core.editor "code --wait"
git config --list

Repository Basics

git init                    # Initialize new repo
git clone <url>             # Clone remote repo
git status                  # Check current state
git add <file>              # Stage a file
git add .                   # Stage all changes
git commit -m "message"     # Commit staged changes
git log                     # View commit history
git log --oneline           # Compact history

Branching

git branch                  # List branches
git branch <name>           # Create branch
git switch <name>           # Switch branch
git switch -c <name>        # Create + switch
git merge <branch>          # Merge into current
git branch -d <name>        # Delete branch
git branch -m <old> <new>   # Rename branch

Diff & Stash

git diff                    # Unstaged changes
git diff --staged           # Staged changes
git diff <branch1> <branch2>
git stash                   # Stash changes
git stash list              # List stashes
git stash pop               # Apply + drop stash
git stash apply stash@{0}   # Apply specific stash
git stash clear             # Clear all stashes

Remote & GitHub

git remote -v               # List remotes
git remote add origin <url> # Add remote
git push -u origin main     # Push + set upstream
git push                    # Push (after -u set)
git fetch origin            # Fetch (no merge)
git pull origin main        # Fetch + merge
git pull                    # Pull (after -u set)

History Management

git rebase <branch>         # Rebase current onto branch
git rebase --continue       # Continue after conflict
git rebase --abort          # Abort rebase
git reflog                  # View HEAD history
git reset --hard <hash>     # Reset to commit

Tags

git tag                     # List tags
git tag v1.0.0              # Lightweight tag
git tag -a v1.0.0 -m "msg"  # Annotated tag
git push origin v1.0.0      # Push tag
git tag -d v1.0.0           # Delete local tag