Git Basics & GitHub Workflow: Hands-On Practice Session Learn Git from zero — then grill yourself with 10 quizzes before you touch real code

🎯 What You'll Learn

• What Git is and why it dominates version control
• How to install and configure Git on Windows, macOS, and Linux
• The three-tree architecture (Working Directory → Staging → Repository)
• Every core command: init, clone, add, commit, status, log, diff
• Branching, merging, and resolving conflicts
• Full GitHub workflow: remote, push, pull, pull requests, forks
• 10 quizzes to reinforce every concept before moving on

📋 Before You Begin

• A computer running Windows, macOS, or Linux
• A GitHub account (free — sign up at github.com)
• Comfort typing commands in a terminal / command prompt
• No prior Git knowledge needed — we start from absolute zero

1. What Is Git and Why Do You Need It? Beginner

Git is a distributed version control system created by Linus Torvalds in 2005 to manage the Linux kernel — a project with thousands of contributors worldwide. It tracks every change to every file in your project, forever.

Here's what Git gives you:

• History — Every change is recorded with who made it, when, and why. You can travel back to any point in time.
• Branching — Work on new features without touching the stable code. Branches are lightweight and cheap.
• Collaboration — Multiple people can work on the same files simultaneously. Git merges their work intelligently.
• Backup — Every developer has a full copy of the entire project. No single point of failure.
• Accountability — Every commit is signed with the author's name and email. You know exactly who changed what.

Git vs GitHub — What's the Difference?

This confuses every beginner. Here's the simplest explanation:

Analogy: Git is your engine — it does the real work of tracking changes. GitHub is a parking lot where you share your car (repo) with others. You need the engine to drive; the parking lot just makes it easy to park together.

2. Installation & First-Time Setup Beginner

Installing Git

Configure Your Identity

Git stamps every commit with your name and email. Set them once and forget them:

git config --global user.name "Your Full Name"
git config --global user.email "[email protected]"

Set Your Default Editor

Git sometimes opens a text editor (for commit messages, merge descriptions, etc.). Set it to VS Code (or your preferred editor):

git config --global core.editor "code --wait"

Verify Configuration

git config --list

3. Your First Repository: git init Beginner

A repository (or "repo") is simply a folder that Git is watching. To turn any folder into a Git repository:

mkdir my-first-repo
cd my-first-repo
git init

That's it. Git creates a hidden .git/ folder inside your project. This folder is the engine room — it contains the entire history, all branches, all configuration. Never touch it directly.

Checking the State: git status

The most-used command in Git. Run it constantly to stay oriented:

git status

Right now, it tells you: "No commits yet" and lists your untracked files (if any). We'll fix that next.

4. The Three Trees: Working Directory, Staging, Repository Beginner

This is the single most important concept in Git. Understand this, and everything else clicks into place.

Git manages your files across three "trees":

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│   Working       │     │     Staging     │     │   Repository    │
│   Directory     │ ──▶ │     Area        │ ──▶ │ (.git/ history) │
│                 │     │  (Index)        │     │                 │
│  Your editor    │     │  "git add"      │     │  "git commit"   │
│  changes here   │     │  prepares here  │     │  saves forever  │
└─────────────────┘     └─────────────────┘     └─────────────────┘

5. Tracking Changes: status, add, commit, log, diff Beginner

Let's create a file and walk through the cycle.

echo "Hello, Git!" > README.md

git status

git add README.md

git commit -m "Add README with greeting"

git log

git log — Your Project's Diary

commit 1a2b3c4d5e6f7g8h9i0j...
Author: Your Name <[email protected]>
Date:   Thu Jul 9 14:30:00 2026 +0530

    Add README with greeting

Every commit has a unique 40-character hash (like a fingerprint). You use this hash to reference the commit when you need to travel back in time.

Useful variants:

git log --oneline          # Compact view: one line per commit
git log --graph            # Show branch structure visually
git log -p                 # Show the actual changes (diff) for each commit

git diff — See Changes Before You Stage

Before staging, see exactly what changed:

# View unstaged changes
git diff

# View staged changes (what will be committed)
git diff --staged

6. Branching: Work Without Fear Beginner

A branch is a movable pointer to a commit. When you create a new branch, you're creating a parallel universe where you can experiment freely without affecting the main code.

main     ●──●──●──●
                  ↑ (main is here)

feature  ●──●──●──●──●──●
         (you branch off here)    (new commits only on feature)

Branching Commands

# List branches (* = current branch)
git branch

# Create a new branch
git branch feature-login

# Switch to it
git checkout feature-login

# Create AND switch in one command (modern way)
git checkout -b feature-login

git checkout -b add-footer

echo "<footer>© 2026 Our Team</footer>" > footer.html
git add footer.html
git commit -m "Add footer to all pages"

git checkout main

7. Merging & Conflict Resolution Intermediate

Merging combines the work from two branches. When your feature is ready, you merge it back into main.

# Switch to the branch you want to merge INTO
git checkout main

# Merge the feature branch INTO current branch
git merge add-footer

If both branches changed the same lines of the same file, Git produces a merge conflict. It doesn't know which version to keep, so it asks you to decide.

When a Conflict Happens

Git marks the conflict in the file:

<<<<<<< HEAD
This line was added on main
=======
This line was added on the feature branch
>>>>>>> add-footer

Your job: Edit the file to keep the correct version (or a combination of both), remove the conflict markers, then:

git add <file>
git commit -m "Resolve merge conflict between main and add-footer"

8. GitHub: Connect Your Local Repo to the Cloud Beginner

So far, everything has been local — on your machine. Now let's put it on GitHub so you can share it, back it up, and collaborate.

Step 1: Create a Repository on GitHub

1. Log in to github.com
2. Click the + icon (top-right) → New repository
3. Name it my-first-repo (the same name as your local project)
4. Leave it public (or check "Private" if you prefer)
5. Do NOT check "Initialize with README" — you already have one locally
6. Click Create repository

Step 2: Add the Remote

A remote is a URL linking your local repo to GitHub. The conventional name is origin.

git remote add origin https://github.com/YOUR_USERNAME/my-first-repo.git

Step 3: Push Your Code

git push -u origin main

The -u flag sets upstream tracking — after this, you can simply type git push and git pull without specifying the remote and branch every time.

9. Push, Pull, and Fetch — The Sync Triad Beginner

Once your local repo is connected to GitHub, you have three commands to sync changes:

The Safe Workflow

# Step 1: Get latest info without merging
git fetch origin

# Step 2: See what's different
git log main..origin/main

# Step 3: Now merge (or use pull for a quick shortcut)
git pull origin main

10. Pull Requests: The Heart of Collaboration Intermediate

A Pull Request (PR) is GitHub's mechanism for proposing changes. Instead of merging directly to main, you:

1. Create a branch, make changes, push the branch to GitHub
2. Open a PR asking to merge your branch into main
3. Teammates review the code, leave comments, request changes
4. Once approved, merge the PR

The Complete PR Workflow

git checkout -b add-contact-form

echo "<form>Contact us...</form>" > contact.html
git add contact.html
git commit -m "Add contact form page"

git push -u origin add-contact-form

git checkout main
git pull origin main

In a team, step 4 is where the magic happens — teammates review your code, catch bugs, and discuss improvements before the code lands in main.

11. Forking: Contributing to Others' Repos Intermediate

Forking is how you contribute to a repository you don't own. A fork is your personal copy of someone else's repo on GitHub.

The Fork Flow

1. Go to any public repo on GitHub (e.g., facebook/react)
2. Click Fork (top-right) — creates a copy under YOUR GitHub account
3. Clone YOUR fork to your local machine

git clone https://github.com/YOUR_USERNAME/react.git
cd react

4. Add the original repo as an upstream remote

git remote add upstream https://github.com/facebook/react.git

5. Sync your fork with the original

git fetch upstream
git checkout main
git merge upstream/main

6. Create a branch, make changes, push to YOUR fork, and open a PR from your fork to the original repo

12. Undoing Changes: reset, revert, restore Intermediate

Everyone makes mistakes. Git has three different tools to undo things, depending on where the mistake is.

13. .gitignore — What NOT to Commit Beginner

Some files should never be committed to Git:

• Secrets: .env files with API keys, passwords, database URLs
• Build artifacts: node_modules/, dist/, .next/, compiled binaries
• OS files: .DS_Store (macOS), Thumbs.db (Windows)
• IDE files: .vscode/, .idea/ (IntelliJ), *.swp (Vim)
• Logs & caches: *.log, .cache/, __pycache__/

Create a .gitignore file in your project root listing patterns to exclude:

# .gitignore
node_modules/
.env
*.log
.DS_Store
dist/
__pycache__/
*.pyc

Then commit it:

git add .gitignore
git commit -m "Add .gitignore"

14. Practice Session: Build a Mini Project End-to-End Intermediate

Let's put everything together. From scratch, build a small HTML project and push it to GitHub — using branches, commits, and a pull request.

mkdir recipe-site
cd recipe-site
git init
echo "# My Recipe Collection" > README.md
git add README.md
git commit -m "Initial commit with README"

cat > index.html << 'EOF'




  
Welcome to My Recipe Collection
  
Delicious recipes from around the world.


EOF
git add index.html
git commit -m "Add homepage skeleton"

git checkout -b add-recipe-page

cat > pancakes.html << 'EOF'




  
Fluffy Pancakes
  
Ingredients
  

    
1 cup flour
    
1 cup milk
    
1 egg
  
  
Instructions
  
Mix, pour, flip, enjoy!


EOF
git add pancakes.html
git commit -m "Add pancakes recipe page"

sed -i '/<\/ul>/a Pancakes' index.html
# If sed doesn't work on Windows, manually add: Pancakes
git add index.html
git commit -m "Add pancakes link to homepage"

git checkout main
git merge add-recipe-page
git branch -d add-recipe-page

# Create "recipe-site" on GitHub (no README, no .gitignore)
git remote add origin https://github.com/YOUR_USERNAME/recipe-site.git
git push -u origin main

15. Cheat Sheet & Key Takeaways Beginner