Contents

Section Slides
Intro Sound familiar? · Today's plan
01 · Version control What is it? · Snapshots · 3 questions · Why use it? · Three kinds · Distributed · Quick check
02 · Git What is Git? · Born in 2005 · 93% use Git · Repository · Three places · Commits · Commit chain · Commit messages
03 · GitHub Git ≠ GitHub · An analogy · By the numbers · $7.5 billion · Everyday projects · Portfolio · Public vs private · Match it up
04 · GitHub Desktop What is it? · Git in a terminal · Same Git, two ways · The top bar · Changes vs History
05 · Core workflow Two copies · Clone · Change files · See what changed · Commit · Push · Fetch · Pull · Fetch vs Pull · Everyday loop · Commit ≠ Push · Discard · Quick check · Vocabulary
06 · Collaboration The problem · Branches · Pull request · Merge conflict · Fork · Issues · How a team works · Vocabulary · Match it up
Wrap-up Remember · Build your first repo · All vocabulary

Git, GitHub & GitHub Desktop

Saving your work like a professional

💾 Version control · 🤝 Collaboration · 🖥️ Desktop

Sound familiar?

  • 📁 monster
  • 📁 monster_v2
  • 📁 monster_WORKING
  • 📁 monster_new_eyes_BROKEN
  • 📁 monster_FINAL_really

Google Docs saves your history for you. Processing doesn't.

Today's plan

  1. Version control
  2. Git
  3. GitHub
  4. GitHub Desktop
  5. The core workflow
  6. Collaboration

01 · Version control

A time machine for your files

What is version control?

A system that records changes to files over time — so you can go back to any version later.

  • ⏪ Go back to any version, not just the last one
  • 📦 Saves space: it only stores what changed
  • 🎨 Works for any file: code, images, sounds, game levels
  • 📄 Like Google Docs Version history, but built for code and teams

Every save is a snapshot

Pro Git diagram: five versions over time, each a snapshot of files A, B and C

Version control answers 3 questions

  • What changed? Line 14: speed = 5 became speed = 8
  • Who changed it? Maya
  • When and why? Tuesday, 3:15 · "Make the ghost faster"

Why use version control?

  • 🛟 Undo anything: broke your code? Go back to the last version that worked
  • 🧪 Experiment without fear: try a wild idea, then keep it or throw it away
  • 💾 A backup somewhere else: computer dies, your work survives

Three kinds of version control

Type Where the history lives Example
Local Only your computer Copying folders by hand
Centralized One central server Subversion (SVN)
Distributed Every computer has a full copy Git
Pro Git diagram: a server and two computers, each with a full version database

Distributed: everyone has a full copy

  • 💻 Work offline
  • 🛟 Any copy can restore the rest
  • 🤝 Share changes directly

🤔 Quick check

Your school laptop gets wiped overnight.

With version control on GitHub, what do you lose?

02 · Git

The tool that tracks your changes

What is Git?

Free software on your computer that tracks every change in a project folder.

💻 Runs on your computer · 🆓 Free · ✈️ Works offline

Born in 2005

2005 2008 2018 2025
🐧 Git created 🐙 GitHub launches Microsoft buys GitHub 180M+ developers

🐧 Linus Torvalds, the creator of Linux, made Git to manage Linux's code.

The industry standard

93% use Git

of developers, in Stack Overflow's 2022 survey

📁 Repository = folder + history

A repository (repo) is a project folder that Git is tracking. It holds two things:

  • 📄 Your files: code, images, sounds. You open and edit them like any other files.
  • 🗄️ A hidden .git folder: the full history. Every snapshot, every message, who made each change, and when.

Three places your work lives

  1. 📝 Your folder: the files you see and edit. Saving puts work here.
  2. ☑️ Checked files: the changes you pick for your next commit
  3. 📚 History: every commit, kept for good. Committing puts work here.

Saved ≠ committed. Only commits go into the history.

What is a commit?

A save point: a snapshot of your project + a message explaining the change.

📸 Snapshot · ✍️ Message · 👤 Author · 🕒 Time

Commits form a chain

① ➜ ② ➜ ③ ➜ ④
Initial commit Add player Add enemies Fix jump bug (newest)

Good commit messages

✅ Good ❌ Bad
Add jump sound effect stuff
Fix score going negative asdf
Update README with controls changes
Remove unused images final final

Start with an action word. Keep it short.

03 · GitHub

Git projects, online and shared

Git ≠ GitHub

💻 Git 🌐 GitHub
What A program A website
Job Tracks changes Stores & shares projects
Where Your computer Online

An analogy

🎥 Git is like your camera

📺 GitHub is like YouTube

  • 🎬 Recording a clip = commit
  • ⬆️ Uploading it = push
  • ⬇️ Downloading someone's video = clone
  • 💬 Comments = issues and reviews
  • ✏️ One difference: on GitHub, others can suggest changes

GitHub by the numbers

👩‍💻 180M+ developers

📁 630M repositories

⬆️ 986M commits pushed in one year

💰 $7.5 billion

Microsoft bought GitHub in 2018.

You use GitHub projects every day

  • 🎨 Processing: the app we code in
  • 🧮 Windows Calculator
  • 🎮 Godot: the game engine behind Buckshot Roulette and Brotato
  • ⚡ Pokémon Showdown: online Pokémon battles
  • ♟️ Lichess: free online chess

Your GitHub is your portfolio

Colleges and employers can see what you've built — not just your grades.

  • 📂 Your projects: every public repo you make
  • 🟩 Your activity: green squares for the days you commit
  • 📝 Your explanations: a README that says what each project does
  • 👔 Pick a username you'd be fine showing a college or a boss

🔓 Public vs 🔒 private

🔓 Public 🔒 Private
Anyone can see it Only you + people you invite
Portfolios, open source Drafts, personal work

The repo name my-first-repo on GitHub with its Private label outlined

Look for the label next to the repo name.

🤔 Match it up

What is it? Word
A program on your computer that tracks changes ?
A website where people store and share projects ?
A project folder + its full history ?
A save point: a snapshot + a message ?
Every computer has the full history ?
Anyone on the internet can see it ?

Word bank: commit · distributed · Git · GitHub · public · repository

04 · GitHub Desktop

Git with buttons instead of commands

What is GitHub Desktop?

A free app that runs Git for you — click buttons instead of typing commands.

🪟 Windows · 🍎 Mac

A Git Bash window. git status shows interests.txt modified, in red. Then git add, git commit with the message "Add Rocket League to interests", and git push, which uploads the commit to github.com/student/my-first-repo

Git in a terminal

  • ⌨️ Pros type commands
  • 💬 Git answers in text
  • 🖱️ We'll click buttons

Same Git, two ways

Command line GitHub Desktop
git clone <url> File → Clone repository
git add . ☑️ Check the files
git commit -m "Add logo" Type summary → Commit
git push Push origin
git pull Pull origin

A quick tour: the top bar

The GitHub Desktop top bar: Current repository my-first-repo, Current branch main, and Push origin with 2↑, outlined

Repository · Branch · Sync button

The History tab in GitHub Desktop: eight commits in my-first-repo, newest at the top, and the two files added by the selected commit

Changes vs History

Changes = right now

History = every save point

05 · The core workflow

Clone · Commit · Push · Pull

Two copies of every project

💻 Local ⟶ push ⟶ ☁️ GitHub

💻 Local ⟵ pull ⟵ ☁️ GitHub

GitHub's nickname in Git: origin

The Clone a repository window in GitHub Desktop, with my-first-repo selected and the Clone button outlined

📥 Clone

Download a full copy of a repo from GitHub — linked so you can sync later.

File → Clone repository → pick it → Clone

✏️ Change files

Edit, add, or delete files in the repo folder. GitHub Desktop notices automatically.

The Changes tab listing three changed files: my-drawing.png with a yellow dot, and my-second-drawing.png and my-third-drawing.jpg with green plus signs GitHub Desktop comparing two versions of my-drawing.png side by side: the old orange cat labeled Deleted and the new yellow Pac-Man labeled Added

🟨 Dot = changed · 🟩 + = new · 🟥 − = deleted

🔍 See exactly what changed

GitHub Desktop diff of interests.txt: the old line "I like turtles" in red with a minus sign, and four new lines in green with plus signs

🟩 Green = added · 🟥 Red = removed

The Changes tab with interests.txt checked, the Summary box outlined with "Change wording on interests.txt" typed in, and the blue Commit 1 file to main button

✅ Commit

Save a snapshot on your computer, with a short message.

  • ☑️ Check the files
  • ✍️ Write a Summary of what you changed
    • Start with an action word: Add, Fix, Update
    • Be specific: Fix score going negative, not stuff
    • Keep it short: about 50 characters
  • 🔵 Click Commit to main

⬆️ Push

Upload your commits from your computer to GitHub.

The GitHub Desktop top bar with the Push origin button and its 2↑ outlined

🔄 Fetch

Ask GitHub: "Is there anything new?" Your files don't change.

The GitHub Desktop top bar with the Fetch origin button outlined; under it, "Last fetched just now"

  • 🔍 Checks for commits you don't have yet
  • 🔢 Something new? The button turns into Pull origin ↓
  • ✅ Nothing new? Start working
  • 📅 Click it at the start of every class

⬇️ Pull

Download new commits from GitHub to your computer.

The GitHub Desktop top bar with the Pull origin button and its 1↓ outlined

Fetch vs Pull

🔄 Fetch ⬇️ Pull
Asks GitHub "Anything new?" "Give me what's new"
Changes your files? No Yes
GitHub Desktop button Fetch origin Pull origin

The everyday loop

🔄 Fetch ➜ ⬇️ Pull ➜ ✏️ Change ➜ ✅ Commit ➜ ⬆️ Push

Repeat every class. (Clone once per computer.)

Commit ≠ Push

✅ Commit ⬆️ Push
Saves on your computer Uploads to GitHub

GitHub Desktop's Push commits to the origin remote box: You have 1 local commit waiting to be pushed to GitHub

Committed but didn't push? Your teacher can't see it.

The Changes tab with interests.txt right-clicked; the menu's top option, Discard changes…, is outlined

🛟 Undo with Discard

Right-click → Discard changes

Back to your last commit

🤔 Quick check

You worked at home last night and pushed.

Now you're at a school computer.

What do you click first?

Vocabulary so far

Word Meaning
Repository Project folder + full history
Clone Copy a repo from GitHub to your computer
Commit Save a snapshot with a message
Push Upload commits to GitHub
Fetch Check GitHub for new commits
Pull Download new commits from GitHub

06 · Collaboration

Many people, one project

The problem with teamwork

👩‍💻 Maya edits game.py

🧑‍💻 Jordan edits game.py

Whose version wins?

🌿 Branches

Pro Git diagram: commits C0 to C2 on master, with two branches, hotfix and iss53, splitting off from C2

A separate line of work — main stays safe.

📬 Pull request

"Here are my changes — please review them and merge them in."

📝 Propose · 💬 Discuss · ✅ Merge

The Open a pull request page on GitHub: base main and compare add-games-list, Able to merge

A pull request with No conflicts with base branch and the Merge pull request button outlined

💥 Merge conflict

Two people change the same line differently.

Git asks a human: which one?

🍴 Fork

Your own copy of someone else's repo — on GitHub.

The Watch, Fork, and Star buttons at the top right of a GitHub repo page, with Fork outlined

Fork ➜ change ➜ pull request back

The Create new issue page for my-first-repo on GitHub: the title "Bug: Pac-man drawing is missing eyes and other features," a description with Description and Expected behavior sections, and the Create button outlined

📋 Issues

A to-do list for the project: bugs, ideas, tasks.

How a team works

  1. 📋 Issue — describe the work
  2. 🌿 Branch — start a separate line
  3. 📬 Pull request — ask for review
  4. 🔀 Merge — join it into main

Collaboration vocabulary

Word Meaning
Branch A separate line of work
Merge Combine one branch into another
Pull request Ask for your changes to be reviewed and merged
Merge conflict Same lines changed two ways — a human decides
Fork Your own GitHub copy of someone else's repo
Issue A bug, idea, or task to track

🤔 Match it up

Situation Use…
Start work on a new computer ?
Finished a small piece of work ?
Messed up a file you haven't committed ?
Leaving class ?
Check whether GitHub has anything new ?
GitHub has new commits; get them ?
Try a risky idea safely ?
Want a teammate to review your code ?
Found a bug in a teammate's game ?

Word bank: branch · clone · commit · discard · fetch · issue · pull · pull request · push

Remember

  • 💻 Git tracks changes on your computer
  • 🌐 GitHub stores and shares them online
  • 🖱️ GitHub Desktop gives you buttons for Git
  • 🔄 Fetch → Pull → Change → Commit → Push
  • ✅ Commit saves it. ⬆️ Push sends it. Push before you leave!
  • ✍️ Good messages start with an action word: Fix score going negative
  • 🌿 Teams use branches and pull requests to keep main safe

Let's build your first repository

📂 Open U02A02 - Your First Repository - Part 1

Git & GitHub vocabulary

Word Meaning Word Meaning
Repository Project folder + full history GitHub Desktop Buttons for Git
Clone Copy a repo to your computer Branch A separate line of work
Commit Save a snapshot + message Merge Combine one branch into another
Push Upload commits to GitHub Pull request Ask to review + merge your changes
Fetch Check GitHub for new commits Merge conflict Same lines changed two ways; you pick
Pull Download new commits Fork Your GitHub copy of someone's repo
Git Tracks changes on a computer Issue A bug, idea, or task to track
GitHub Stores and shares repos online

CONTENTS - Click any link to jump to that slide. Every slide's footer has a "Contents" link that brings you back here. - Use it to pick up where you left off on a new day, or to jump to a section when students ask about it. - The lesson overview, handouts, and suggested teaching sequence are in the notes on the next slide (the title slide). - Links work in the HTML version (GitHub Pages) and in a browser. They may not work in the VS Code preview.

Lesson overview: roughly two 45-minute class periods if you pause for every discussion question, or one long block if you move quickly. Students should leave able to: (1) explain what version control is and why programmers use it; (2) tell the difference between Git, GitHub, and GitHub Desktop; (3) define repository, commit, push, pull, fetch, and clone in their own words; (4) describe how teams collaborate with branches and pull requests. This deck pairs with the two handouts in the class repo: U02A01 - Creating your GitHub Account (creating accounts and signing in to GitHub Desktop) and the two-part practice, U02A02 - Your First Repository - Part 1 (create, commit, push) and U02AXX - Your First Repository - Part 2 (sync, undo, branch, share). Between the two parts come U02A03 - GitHub Quiz, a Google Form on the whole deck; U02A04 - Draw Your Game Character, a first Processing sketch saved in a second repo, which repeats Part 1's loop with less help; and U02A05 - Code Detective, more drawing practice in that repo. The quiz asks about branches, merge conflicts, pull requests, forks, and issues, so teach the Collaboration section before giving it. A good sequence is: this deck through the Core Workflow section, then Part 1, then the Collaboration section, then the quiz (U02A03), then U02A04, then U02A05, then Part 2 (Tasks 1–4 one day, Tasks 5–9 the next). Framing for students: almost every piece of software they use — games, apps, websites — is built by teams who use these exact tools every day. Learning them now is learning the real workflow, not a school-only exercise. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, chapter 1 "Getting Started" (git-scm.com/book), licensed CC BY-NC-SA 3.0. GitHub Docs, "GitHub Desktop" documentation (docs.github.com/en/desktop), licensed CC BY 4.0. Update every year: the GitHub numbers come from GitHub's Octoverse report, which usually comes out in late October or early November (github.blog/news-insights/octoverse/). As of October 2026, Octoverse 2025 is still the newest one. When a new report comes out, update: the 2025 column on "Born in 2005"; the "GitHub by the numbers" slide and its notes; the 43.2 million pull requests in the Pull request notes; and the statistics credit on "Let's build your first repository." The 93% Git figure is from Stack Overflow's 2022 survey; replace it if a newer survey asks about version control again.

Hook. Students write in Google Docs, which saves every version for them (File → Version history), so the "essay_FINAL_v2" problem isn't one they've had. Their Processing sketches are different: Processing has no version history. Once you save over a sketch, the old code is gone, and Ctrl+Z stops working when you close Processing. So when a sketch finally works and you want to try something risky, the only safety net is File → Save As, which copies it into a new sketch folder. Do that a few times and your sketchbook looks like this. Ask: "Which one actually works? What's different between monster_v2 and monster_WORKING? The new eyes broke it. How do you get the old eyes back without losing the new colors you added?" Nobody can answer from the folder names alone. It gets worse with a partner: they email you their copy, and now there's monster_JORDAN_edits too. Whose version wins? The point to land: programmers had this exact problem, except with hundreds of files and dozens of people editing at once. Version control was invented to solve it. Git is like Google Docs' Version history for code, with two differences: you decide when to save a version, and you write a note saying what changed. Today we're learning Git and GitHub, the website most people use with it. Optional quick discussion (2–3 stories): "Has a sketch ever worked, then you changed something and couldn't get it back?" If students haven't had this happen yet, ask about a game where they lost progress by saving over the wrong save slot.

Roadmap for the lesson. Point out that the first three sections are about ideas ("what and why"), and the last three are about doing ("how"). Vocabulary preview — students will hear these words throughout: repository (repo), commit, push, pull, fetch, clone, branch, merge, pull request, fork. Don't define them yet; just tell students that by the end, they'll be able to explain every one. If you split this over two days, stop after section 5 (The core workflow), run U02A02 - Your First Repository - Part 1, and do section 6 the next day.

Section 1 introduces the big idea before any specific tool. Emphasize that version control is a concept, and Git is one tool that does it — like "word processor" is a concept and Google Docs is one tool. Students who understand the concept will be able to learn any version control tool later.

Definition, almost word-for-word from Pro Git chapter 1: "Version control is a system that records changes to a file or set of files over time so that you can recall specific versions later." Key points to stress: - It records changes automatically and precisely, not by you making copies. - It works for any kind of file: code, essays, images, game levels, 3D models. Programmers use it most, but designers, writers, and scientists use it too. - "Go back to any version" is the superpower. Not just the last one — any one. Connect to something students already know: Google Docs has "Version history" (File → Version history). That's a simple form of version control. Git is a much more powerful version of the same idea, built for code and teams. The "saves space" bullet connects back to the sketchbook on slide 3: every Save As copied the whole sketch, even the parts that didn't change. Version control is smarter. For your own background, Git's version: each save point is a full snapshot of the project, but files that didn't change aren't stored again (Git just points to the copy it already has), and everything is compressed. The next slide, "Every save is a snapshot," shows this with a diagram. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.1 "About Version Control" (git-scm.com/book/en/v2/Getting-Started-About-Version-Control), CC BY-NC-SA 3.0.

This diagram from Pro Git shows how Git thinks about your project: as a series of snapshots over time. Each "Version" across the top is a moment you chose to save. Under each version are the files as they looked at that moment. Walk through it left to right: - Version 1: three files, A, B, C. - Version 2: File A changed (A1) and File C changed (C1). File B didn't change — the dashed outline means Git didn't store a new copy, it just points back to the B it already has. - Version 3: only C changed again (C2). - And so on. Why this matters: because Git stores every snapshot, you can jump back to Version 2 and see exactly what every file looked like at that moment. And because it doesn't re-store unchanged files, it stays efficient even for huge projects. Classroom analogy: it's like a photo album of your project. Each photo shows the whole project at one moment. You can flip back to any page. Image: Scott Chacon and Ben Straub, Pro Git, 2nd edition, figure "Storing data as snapshots of the project over time," section 1.3 "What is Git?", CC BY-NC-SA 3.0.

Reveal one at a time. Each question has a made-up example from a game project, so students see the kind of answer Git gives. What changed? — Version control can show you the exact lines that are different between any two versions. Not "something in the file changed" but "line 14 used to say X and now says Y." Who changed it? — Every change is labeled with the person who made it. On a team, this means you know who to ask about a piece of code. (It's not about blame — it's about knowing who has context.) When and why? — Every change has a timestamp and a short message written by the person who made it, explaining why. "Fix crash when score goes negative." Months later, that message tells you why the code looks the way it does. Ask students: Which of these would have helped in a group project you've done? Usually "who changed it" gets a laugh.

Three big benefits. Reveal one at a time. Undo anything: The first big practical benefit: safety. When you're programming, it is extremely common to make a change, break something, and not remember exactly what you changed. Without version control, you're stuck trying to remember or retype things. With version control, you can see exactly what you changed since the last save point, and throw those changes away to get back to working code. Students will practice this directly in Task 3 of U02AXX - Your First Repository - Part 2: they delete their own picture on purpose and get it back with "Discard changes." Important nuance: version control can only bring back what you saved into it (committed). If you never committed a file, Git never had a copy. This is why "commit often" is the number-one habit. Experiment without fear: The second benefit: freedom to experiment. Because you can always go back, you can try risky changes — rewriting a game's movement system, redesigning a website — without worrying about wrecking the version that works. Later in the deck (Collaboration section) we'll see branches, which take this further: you can work on an experiment in a separate "copy" of the project while the main version stays safe. Connect to students' experience: in a video game, you save before the boss fight. If it goes badly, you reload. Version control is a save system for your project — and you get unlimited save slots. A backup somewhere else: Third benefit: backup. When you use version control with an online service like GitHub, a full copy of your project and its history lives on the internet, not just on your computer. If your laptop is lost, stolen, broken, or a school computer gets wiped, your work is still there. Make the habit concrete for class: "Push before you leave." If you only save on a school computer and don't upload it, it may not be there tomorrow. Note the difference from just using Google Drive: Drive backs up the latest version of your files. Version control backs up every version and the reasons for each change.

A reference slide on the history of version control, from Pro Git section 1.1. Local version control: the earliest approach. You keep versions on your own computer, maybe with a simple tool, maybe just by copying folders. Problem: no way to collaborate, and if your computer dies, everything is gone. Centralized version control (CVCS): one server holds the full history, and everyone checks files out from it. Examples: CVS, Subversion (SVN), Perforce. This made collaboration possible. Problem: the server is a single point of failure. If it goes down, nobody can save changes; if its disk is lost without backups, the whole history is gone. Distributed version control (DVCS): every person has a full copy of the entire project and its full history. Examples: Git, Mercurial. If any server dies, any person's copy can restore it. You can also work offline and save versions without an internet connection. Git is distributed, which is one reason it won. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.1 "About Version Control," CC BY-NC-SA 3.0. More on centralized version control: In a centralized system, the version history (the "Version Database") lives only on the central server. Each person's computer has just the current files they checked out. Ask: What happens if the server goes offline for a day? (Nobody can save versions or see history.) What if the server's hard drive fails and there's no backup? (The whole history is gone.) This was the standard for many years and worked well enough for many companies — but it has that single weak point. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.1, CC BY-NC-SA 3.0.

In a distributed system like Git, every computer has the complete version database — every version of every file. Computer A and Computer B each have Versions 1, 2, and 3, just like the server. What this means in practice: - You can commit (save versions) with no internet connection. Work on a bus, at home with no Wi-Fi, anywhere. - If the server is lost, any person's copy can rebuild it. - People can share changes directly with each other, not only through the server (the arrow between Computer A and Computer B). In our class, the "Server Computer" is GitHub, and "Computer A" is the school computer or your laptop. When you clone a repository later, you are downloading the full version database, not just the latest files. Image: Scott Chacon and Ben Straub, Pro Git, 2nd edition, figure "Distributed version control diagram," section 1.1, CC BY-NC-SA 3.0.

Think-pair-share, about 2 minutes. Expected answer: only the work you didn't commit and push. Everything you committed and pushed to GitHub is safe; you can clone it onto any computer and keep going. Push students to be precise: - Changes that were saved to files but never committed: lost. - Changes committed but never pushed: lost (they only lived on that laptop). - Changes committed and pushed: safe. This sets up the clone → commit → push vocabulary in section 5. Don't worry if students don't know those words yet — come back to this question after section 5 and ask again.

Section 2 is about Git itself: what it is, where it came from, and the core ideas of repository and commit. Stress that Git is a program on your computer — it is not a website.

Git is a version control program. Key facts: - It runs on your computer. It is not a website. (This is the number-one confusion — GitHub is the website. We'll get there.) - It's free and open source: anyone can download it, use it, and read its source code. - It works offline. Since every copy is complete, you can save versions without internet. - It works with any files, but it's best with text files like code, where it can show exactly which lines changed. Professional developers often use Git by typing commands in a terminal (like `git commit`). In our class we'll mostly use GitHub Desktop, an app with buttons that runs Git for us. Same Git underneath. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.3 "What is Git?", CC BY-NC-SA 3.0. git-scm.com (the official Git website).

A quick timeline. 2005 — Git is created by Linus Torvalds, the creator of the Linux operating system. The Linux team had been using a commercial version control tool called BitKeeper for free; in 2005 that arrangement ended. Torvalds decided to write his own tool, with goals of speed, simple design, strong support for many people working in parallel, being fully distributed, and handling huge projects like the Linux kernel. Git was hosting its own development within days of the first code being written in April 2005. 2008 — GitHub launches: a website where people can store Git projects online and collaborate on them. 2018 — Microsoft buys GitHub for $7.5 billion in stock (announced June 2018). More on that in section 3. 2025 — GitHub reports more than 180 million developers on the platform (Octoverse 2025). The 🐧 emoji is a nod to Tux, the Linux penguin mascot. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.2 "A Short History of Git," CC BY-NC-SA 3.0. Microsoft News Center, "Microsoft to acquire GitHub for $7.5 billion," June 4, 2018. GitHub Blog, "Octoverse: A new developer joins GitHub every second as AI leads TypeScript to #1," October 2025. Folded in from a former slide, "Built for a giant project": Git was designed to handle the Linux kernel — one of the largest collaborative software projects in the world, with thousands of contributors around the globe. Linux runs most of the world's web servers, every Android phone (Android is built on the Linux kernel), and most supercomputers. The design goals Torvalds listed (from Pro Git section 1.2): speed; simple design; strong support for non-linear development (thousands of parallel branches); fully distributed; able to handle large projects like the Linux kernel efficiently in speed and data size. The point for students: the tool you're about to use in a beginner class is the same tool used to coordinate thousands of professional engineers. If it can handle Linux, it can handle your class project. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.2 "A Short History of Git," CC BY-NC-SA 3.0.

In Stack Overflow's 2022 Developer Survey — one of the largest surveys of programmers in the world, with over 70,000 respondents — about 93% of developers said they use Git. Stack Overflow wrote that "no other technology is as widely used as Git" in their survey. The next-most-common answers (like SVN) were far behind. What this means for students: if you go into any programming job, internship, or college CS program, you will be expected to know Git. It's as standard as knowing how to use a keyboard. Discussion prompt: "What other tool is used by 93% of people in a field?" (e.g., nearly every office worker uses email; nearly every student uses a search engine.) This is still the newest figure: as of October 2026, the public results of the 2024, 2025, and 2026 Stack Overflow surveys don't report a Git share. Check again each year, and update the slide if a newer survey asks about version control. Sources / teaching basis: Stack Overflow Blog, "Beyond Git: The other version control systems developers use," January 9, 2023 (reporting 2022 Developer Survey results), stackoverflow.blog/2023/01/09/beyond-git-the-other-version-control-systems-developers-use/.

A repository (repo) is a project folder that Git is tracking. It contains: - Your normal files — code, images, text — that you can open and edit like any other files. - A hidden folder named `.git` where Git stores the complete history: every snapshot, every commit message, who made each change, and when. Students usually won't see the `.git` folder because it's hidden by default. That's on purpose — you should never edit it by hand. Let Git (or GitHub Desktop) manage it. Fun fact to share: if you delete the `.git` folder, the folder stops being a repository. Your current files stay, but all the history is gone. (Don't do this!) Each project gets its own repository. A website is one repo; a game is another repo. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.3 "What is Git?" and section 2.1 "Getting a Git Repository," CC BY-NC-SA 3.0.

These are Git's three places for your work, in GitHub Desktop words. Pro Git gives them official names, which students will see in tutorials and in the terminal: 1. Your folder = the working directory (or working tree). These are the files students see in File Explorer and edit in Processing or Notepad. Saving a file (Ctrl+S) changes it here, and only here. 2. Checked files = the staging area. In GitHub Desktop, these are the checkboxes next to each file in the Changes tab: checked means "put this in my next commit." New changes start out checked, so students rarely have to think about it. In the terminal, git add does this job, which is why the "Git in a terminal" slide says "Changes not staged for commit." 3. History = the repository, kept in the hidden .git folder. Committing saves the checked changes here as a new save point. GitHub Desktop shows it in the History tab. The point to land: saved ≠ committed. Ctrl+S only changes the file in your folder; Git has no copy of that version until you commit. If you break a file you never committed, Git can't bring the old version back. Ask: "You saved your sketch and closed Processing. Is that version in Git's history?" (No, not until you commit.) There's a fourth place, GitHub, which comes later: pushing copies your history to GitHub. "Commit ≠ Push" has its own slide in section 5. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 1.3 "What is Git?" ("The Three States"), CC BY-NC-SA 3.0.

Commit is the most important word in Git. A commit is a saved snapshot of the project at one moment. Each commit stores: - Snapshot: what every tracked file looked like. - Message: a short summary written by the person, explaining what changed and why. - Author: who made it (name and email from their Git settings). - Time: when it was made. - (Also: a unique ID, a long code like 6476aa4…, and a link to the commit that came before it.) Analogy: saving a video game. Saving the file in Notepad (Ctrl+S) is like pausing — it updates the file on disk. Committing is like making an official save slot with a label: "Before the boss fight." You can return to that exact slot later. Common misconception: "I saved the file, so it's committed." No — saving updates the file; committing creates a permanent save point in Git's history. Students need to do both.

Each commit points back to the one before it, making a chain — this is the project's history. The bold one on the right, ④ "Fix jump bug," is the newest commit. Read it as a story: "Initial commit" (the project started), then "Add player," then "Add enemies," then "Fix jump bug." Anyone can read the history and understand how the project grew. If "Fix jump bug" actually broke something else, you can look at exactly what changed in commit 4, or go back to commit 3. In GitHub Desktop, this chain is what you see in the History tab — newest at the top. Later, in the Collaboration section, we'll see that this chain can split into branches and join back together.

Commit messages are for your future self and your teammates. Six months from now, "stuff" tells you nothing; "Fix score going negative" tells you exactly what happened. Common conventions: - Start with an action verb in the present tense: Add, Fix, Update, Remove, Rename, Refactor. - Keep the summary short — around 50 characters is a common guideline. GitHub Desktop has a Summary box (short) and an optional Description box for more detail. - Say what changed, not "I did some work." Activity (1 minute): show a vague message, like "updated things," and have students rewrite it for a specific change: "You fixed a typo in the title of your website." Good answers: "Fix typo in page title." Teacher note: you can use students' commit histories to see how their work developed over time, so good messages help them too.

Section 3 introduces GitHub and clears up the most common confusion: Git and GitHub are not the same thing.

This is the most important distinction in the whole lesson. Git is the version control program. It runs on your computer and tracks changes. It works with no internet and no website. GitHub is a website (and company) that hosts Git repositories online. It adds things Git alone doesn't have: a web page for every project, a place to back up your work, tools for teams (pull requests, issues, code review), and profiles that show your work to others. You can use Git without GitHub (just on your computer, or with a different website like GitLab or Bitbucket). But GitHub only works because of Git. Check for understanding: "If the GitHub website went down for an hour, could you still commit on your computer?" (Yes — Git runs locally. You just couldn't push until it came back.)

Analogy that usually clicks: your camera records video; YouTube is where you upload it so others can see it, comment on it, and share it. You can record video without YouTube, but YouTube needs videos to exist. Similarly: Git records your project's history on your computer. GitHub is where you upload that history so it's backed up and others can see it and collaborate. Extend the analogy (the bullets on the slide). Only commit has been taught so far; push and clone come in section 5, and issues and reviews in section 6, so treat them as a preview and don't define them in depth yet: - Recording a clip = committing. - Uploading = pushing. - Downloading someone's video = cloning/pulling. - YouTube comments = GitHub issues and pull request reviews. Analogies always break down somewhere — for example, YouTube viewers can't edit your video, but GitHub collaborators can contribute changes. That difference is exactly what makes GitHub powerful for teams.

All three numbers come from GitHub's Octoverse 2025 report. Reveal one at a time. 180M+ developers: GitHub's Octoverse 2025 report says the platform has more than 180 million developers. That's more than half the population of the United States. Context: GitHub's annual Octoverse report covers activity from September through August. The 2025 report (Sept 1, 2024 – Aug 31, 2025) called it the fastest growth in GitHub's history, with more than 36 million new developers joining in one year. Where do they come from? All over the world — GitHub has reported especially fast growth in India, Brazil, Indonesia, and other countries. Students, hobbyists, and professionals all use it. Sources / teaching basis: GitHub Blog, "Octoverse: A new developer joins GitHub every second as AI leads TypeScript to #1," October 2025 (github.blog/news-insights/octoverse/), and octoverse.github.com. Also share (former slide, "One new developer every second"): GitHub's headline for Octoverse 2025: on average, more than one new developer joined GitHub every second during the year — over 36 million new accounts. Quick math challenge for students: there are 31,536,000 seconds in a year (60 × 60 × 24 × 365). 36 million is more than that, so the average really is more than one per second. Why so much growth? More people learning to code (including students like you), more countries getting online, and AI coding tools making programming more accessible. Sources / teaching basis: GitHub Blog, "Octoverse: A new developer joins GitHub every second as AI leads TypeScript to #1," October 2025. 630M repositories: According to Octoverse 2025, GitHub hosts about 630 million repositories, and about 395 million of them are public — meaning anyone can look at the code. More than 121 million new repositories were created in that one year, which is more than 230 new repositories every minute. What's in all those repos? Websites, apps, games, school projects, research data, documentation, personal notes, books, recipes — even this slide deck lives in a GitHub repository. Your first repository (from the practice tasks) will be one of these. Sources / teaching basis: GitHub Blog, "Octoverse: A new developer joins GitHub every second as AI leads TypeScript to #1," October 2025. 986M commits: Octoverse 2025 reports that developers pushed nearly 1 billion commits in a year — about 986 million, up about 25% from the previous year. Developers also merged an average of 43.2 million pull requests every month. Make it concrete: every one of those commits is a save point like the ones students will make today — a snapshot with a message, an author, and a time. You can connect this back to the "93% of developers use Git" slide: Git is the tool, and GitHub is where a huge share of that work gets shared. Sources / teaching basis: GitHub Blog, "What 986 million code pushes say about the developer workflow in 2025," and "Octoverse: A new developer joins GitHub every second as AI leads TypeScript to #1," October 2025.

In June 2018, Microsoft announced it would acquire GitHub for $7.5 billion in Microsoft stock. GitHub continues to operate as its own platform. Why would a company pay that much for a website where people store code? Because GitHub is where a huge part of the world's software is built — it's the central meeting place for developers. Being connected to that community is extremely valuable. Discussion prompt: "Why might a big tech company want to own the place where developers work?" Possible answers: to understand what developers need, to connect their own tools (like VS Code and Azure), to attract developers to their products, to build AI tools like GitHub Copilot. Sources / teaching basis: Microsoft News Center, "Microsoft to acquire GitHub for $7.5 billion," June 4, 2018.

Many apps and websites students already know are built in the open on GitHub. Anyone can go read the real source code: - Processing — the app we code in. github.com/processing/processing4 - Windows Calculator — the calculator on every Windows computer. Microsoft made it open source in March 2019. github.com/microsoft/calculator - Godot — a free, open-source game engine. Buckshot Roulette and Brotato were both made with it. Buckshot Roulette's developer switched to Godot from Unity after Unity's 2023 pricing change, and has said he values that Godot is open source. github.com/godotengine/godot (Buckshot Roulette is a horror game built around a shotgun, so skip the name if that's not a fit for your class.) - Pokémon Showdown — the online Pokémon battle simulator. github.com/smogon/pokemon-showdown - Lichess — free online chess with no ads. github.com/lichess-org/lila More if students ask: - OBS Studio, the app many streamers use to stream and record their screen. github.com/obsproject/obs-studio - The original 2048 web game. github.com/gabrielecirulli/2048 - Tools students may use later: Python (github.com/python/cpython), Visual Studio Code (github.com/microsoft/vscode), React (github.com/facebook/react), and freeCodeCamp (github.com/freeCodeCamp/freeCodeCamp). Linux has an official read-only copy at github.com/torvalds/linux, but its real development happens over email and on kernel.org. Not every famous open-source app is developed on GitHub: Blender, GIMP, and VLC each use their own sites and keep only copies on GitHub. Optional live demo (2 minutes): open github.com/processing/processing4 or github.com/godotengine/godot and show the number of commits, the contributors, and the Issues tab. Point out that strangers from all over the world contribute to it. Test the links on the school network first; filters may block game sites like Pokémon Showdown or Lichess. Sources: Godot Engine showcase pages for Buckshot Roulette and Brotato (godotengine.org/showcase); Wikipedia, "Buckshot Roulette"; Windows Developer Blog, "Announcing the Open Sourcing of Windows Calculator," March 6, 2019. The bigger point: open source software — code anyone can read, use, and improve — powers much of the internet, and GitHub is where most of it lives. Open source (former slide): Open source means the source code is published with a license that lets anyone view, use, modify, and share it. Git itself is open source. So are Linux, Python, VS Code, Firefox, and many others. Why would people give their work away? - Many people improving software makes it better and more secure faster than one company could. - Developers learn by reading real code. - Companies share tools so the whole industry benefits — and so developers will build on their platforms. - It builds reputation: contributing to a well-known project is impressive on a resume. GitHub made open source collaboration much easier: anyone can fork a project, make a change, and suggest it back with a pull request (we'll see both in section 6). Students can contribute to open source too — fixing a typo in documentation is a real contribution, and many projects label issues as "good first issue" for beginners.

A GitHub profile works like a resume for programmers. It shows: - Your public repositories — the projects you've built. - Your contribution graph — the green squares showing which days you committed. If students ask why theirs is blank: commits only count if they're made with the email on their GitHub account, on the main branch. Activity in private repos (theirs start out private) is hidden unless they turn on "Private contributions" in their profile settings, and then it only shows as a count, with no details. - Your README and project descriptions — how well you explain your work. Many tech employers and internship programs ask for a GitHub link. Some college programs and competitions do too. A few good projects with clear READMEs and a real commit history can say more than a list of skills. This is also why we're careful about usernames and personal information (from the account setup guide): your GitHub is public and professional. Choose a username you'd be fine with an employer seeing. Encourage students: everything they build in this class can become part of their portfolio.

Every repository on GitHub is either public or private (organizations can also have "internal" repos, but students won't see that). Public: anyone on the internet can view the code and its history. They can't change your repo unless you give them permission, but they can read it and copy it. Good for portfolios and open source projects. Private: only you and collaborators you invite can see it. Good for drafts, work you're not ready to share, or anything with information that shouldn't be public. You can switch between them in the repo's Settings (in the "Danger Zone"). Students practice this in Task 9 of U02AXX - Your First Repository - Part 2. Important: the history is public too. If you commit something private (a password, your address) and then delete it in a later commit, it can still be found in the older commit. Check before you make something public — and never commit passwords or personal information in the first place. The screenshot shows the Private label next to the repo name. Student repos start out private; after Task 9, the label says Public. Image: screenshot of github.com by Mr. Sidarous.

Halfway review of sections 1–3, before GitHub Desktop. Have students answer on paper or mini whiteboards, then reveal. Partners can quiz each other first. Answers: - A program on your computer that tracks changes → Git. - A website where people store and share projects → GitHub. - A project folder + its full history → Repository (repo). - A save point: a snapshot + a message → Commit. - Every computer has the full history → Distributed (version control). - Anyone on the internet can see it → Public (repo). Bonus questions: - "You saved your sketch with Ctrl+S. Is it in Git's history?" → No, not until you commit. - "Write a good commit message for fixing a typo in your README." → e.g. "Fix typo in README." - "Name one reason to use version control." → Undo mistakes, experiment safely, or keep a backup.

Section 4 introduces the app students will actually use. Keep it short and visual — they'll learn it best by doing the practice tasks.

GitHub Desktop is a free, open-source app made by GitHub. It gives you a visual interface for Git: - See which files changed, with red and green highlighting. - Commit with a summary box and a button. - Push and pull with one button. - Browse your history. It's built on Git — every button runs real Git commands behind the scenes. So everything students learn transfers directly to command-line Git later. Limits to know: - It runs on Windows and macOS only. It does not run on Chromebooks. (Chromebook users can use GitHub's website for basic tasks, or GitHub Codespaces in the browser.) - It covers the most common Git tasks, not every advanced feature. Professionals often use a mix of apps and the command line. Sources / teaching basis: GitHub Docs, "About GitHub Desktop" (docs.github.com/en/desktop), CC BY 4.0.

This is what Git looks like without GitHub Desktop: Git Bash, the terminal that comes with Git for Windows. It runs four commands in my-first-repo, the repo from the handouts: - git status: what changed? interests.txt, in red. (GitHub Desktop: the Changes tab.) - git add . : include all the changes in the next commit. (GitHub Desktop: the checkboxes.) - git commit -m "Add Rocket League to interests": save a snapshot with a message. (GitHub Desktop: the Summary box and Commit to main.) - git push: upload the commit to GitHub. (GitHub Desktop: Push origin.) Things to point out: - The colored line shows who you are, which folder you're in, and the branch, (main). The $ is where you type. - Git answers in plain text. Most of the push output is progress you can ignore. The last line, main -> main, means it worked. - The commit got an ID, cfaf2e2. Every commit has one; GitHub Desktop shows it in the History tab. Don't have students memorize any of this. The next slide puts each command next to its GitHub Desktop button. Optional live demo: if Git for Windows is installed, open a practice repo in Git Bash and run git status and git log --oneline. In GitHub Desktop on Windows, you can set the shell to Git Bash under File → Options → Integrations, then use Repository → Open in Git Bash. Image: made for this deck from real Git output (Git 2.43) in a practice copy of my-first-repo, drawn with Git Bash's default colors. The push went to a practice copy instead of GitHub, so its "To" line was changed to the GitHub address a real push shows. No license restrictions.

This table shows that GitHub Desktop and command-line Git do the same things. Professionals often use the terminal; beginners often find buttons easier. Both create the same commits in the same repository. Walk through each row: - Clone: copy a repo from GitHub to your computer. - Add: stage changes (choose what goes into the next commit). In Desktop, that's the checkboxes. - Commit: make the save point with a message. The -m means "message." - Push: upload commits to GitHub. - Pull: download new commits from GitHub. You don't need to memorize the commands today. But when students see a tutorial online that uses commands, they'll know what button does the same thing. Optional: if your class will eventually use the terminal, mention that GitHub Desktop can open a terminal in the repo folder (Repository menu → Open in Command Prompt / Terminal).

The top bar of GitHub Desktop always shows three things, left to right: 1. Current repository — which project you're working on. Click it to switch between repos. (Here: "my-first-repo.") 2. Current branch — which line of work you're on. For now, students will always be on "main." (Branches are in section 6.) 3. The sync button — this one changes depending on the situation: - "Fetch origin": checks GitHub for new commits. - "Pull origin" with a number and ↓: there are new commits on GitHub to download. - "Push origin" with a number and ↑: you have commits to upload. (That's what's shown here: 2 commits waiting.) - "Publish repository": the repo isn't on GitHub yet. Teach students to glance at this button before they leave class: if it shows an ↑ number, they haven't pushed yet. Image: screenshot of GitHub Desktop by Mr. Sidarous.

The left sidebar has two tabs: Changes — what's different right now compared to your last commit. New files, edited files, deleted files. This is where you check boxes, write a summary, and commit. History — every commit made in the repo, newest at the top. Click one to see its message, author, time, and which files it changed. (The screenshot shows a practice my-first-repo with eight commits. The selected one, "added my interests and my drawing," added two files.) The ↑ arrows next to the top two commits mean they haven't been pushed yet, which is what the Push origin button's 2↑ means too. Discussion prompt: "Which of these commit messages follow our rules?" Good: "Update README with repository details" and "Revise interests and add new hobbies." Not quite: "added my interests and my drawing" and "renamed my-drawing and added two additional drawings" are lowercase and past tense; "Update interests.txt" is GitHub Desktop's suggested placeholder and doesn't say what changed. "Merge branch 'main' of …" is a message Git writes for you when it combines two lines of work (section 6). A good way to remember: Changes is your to-do list; History is your diary. Image: screenshot of GitHub Desktop by Mr. Sidarous.

Section 5 is the heart of the lesson: the vocabulary and the everyday loop. Every slide here maps directly to a task in the practice handouts (U02A02 - Your First Repository - Part 1 and U02AXX - Your First Repository - Part 2), so you can point students to the handout.

The key mental model for the whole workflow: once your project is on GitHub, there are two copies. Local — the copy on your computer. This is where you edit files and make commits. Remote — the copy on GitHub. Git calls this remote "origin" by default, which is why GitHub Desktop's buttons say "Push origin" and "Pull origin." The two copies don't sync automatically. You move commits between them: - Push: send your new commits from local up to remote. - Pull: bring new commits from remote down to local. Misconception to address: "I committed, so it's on GitHub." No — committing saves to the local copy only. You have to push to update GitHub. You can also have more than one local copy: one on a school computer, one on your laptop at home. GitHub (the remote) is the meeting point that keeps them in sync.

Clone: make a local copy of a remote repository, including its complete history. You usually do this once per computer per project. Clone vs. download: GitHub also has a "Download ZIP" option. That gives you just the current files, with no history and no link back to GitHub. A clone keeps the history and remembers where it came from, so you can push and pull later. Always clone. When do you clone? - You made a new repo on GitHub and want to work on it on your computer. - You're starting work on a school computer you haven't used for this project before. - You want a copy of someone else's project (a teammate's, or an open source project) to work on. This is Task 2 in U02A02 - Your First Repository - Part 1. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 2.1 "Getting a Git Repository — Cloning an Existing Repository," CC BY-NC-SA 3.0. Steps in GitHub Desktop: 1. File → Clone repository. 2. On the GitHub.com tab, choose the repository. (If it's not listed, click the refresh button.) 3. Check the Local path — that's where the folder will go on the computer. Usually Documents\GitHub\repo-name on Windows. If Documents is synced to OneDrive, the path includes OneDrive, like in the screenshot. 4. Click Clone. Point out the Local path box: students should know where their project folder is, because that's where they'll save their files. Any file saved outside that folder won't be tracked. Image: screenshot of GitHub Desktop by Mr. Sidarous. The list is filtered by typing "first" in the Filter box, which helps students who already have several repos.

After cloning, you work normally: open files in Notepad, VS Code, Paint, or any app, and save them. The only rule is that the files must be inside the repository folder. GitHub Desktop watches the folder. As soon as you save a change, it shows up in the Changes tab: - Green + : new file - Yellow dot: modified file - Red − : deleted file Common student mistake: saving a file to Downloads or the Desktop instead of the repo folder. If a file doesn't show up in GitHub Desktop, that's almost always the reason. Use Repository → Show in Explorer to open the right folder. This is Tasks 3 and 4 in U02A02 - Your First Repository - Part 1 (creating a text file and a picture). The screenshots: on the left, the Changes tab after one picture was redrawn (yellow dot) and two new pictures were added (green +). On the right, what GitHub Desktop shows when you click the changed picture: the old version and the new one side by side. Point out that Git tracks pictures too, not just code. The buttons above the pictures (2-up, Swipe, Onion Skin, Difference) are other ways to compare them, fun to try but not needed. Image: screenshots of GitHub Desktop by Mr. Sidarous.

This view is called a diff (short for "difference"). Click a file in the Changes tab and the right side shows exactly which lines changed since your last commit. - Green lines with + were added. - Red lines with − were removed. - When you edit a line, Git shows the old version in red and the new version in green, because it compares whole lines. Why it matters: professionals review the diff before every commit, to catch mistakes — a stray keystroke, debugging code left in, or a password they forgot to remove. Make it a habit: look before you commit. The screenshot shows interests.txt after an edit: the old line "I like turtles" (red, −) was replaced by four new lines (green, +). Things students may ask about: - The two number columns are line numbers: old file on the left, new file on the right. - "@@ -1 +1,4 @@" means line 1 of the old file became lines 1–4 of the new one. Students can ignore it. - "No newline at end of file" just means the file doesn't end with a blank line. It's harmless. - The checkmarks on the left mean every line is included in the next commit. Clicking one leaves that line out, but students won't need that. - This is GitHub Desktop's dark theme. In the light theme, the same lines are light red and light green. This is Task 1 in U02AXX - Your First Repository - Part 2. Image: screenshot of GitHub Desktop by Mr. Sidarous, cropped to the diff.

Commit: record a snapshot of your staged changes in the local repository, with a message. Remember the three parts students should be able to state: 1. It's a snapshot (save point) of the project. 2. It has a message saying what changed. 3. It's saved locally — on your computer — until you push. When should you commit? Whenever you finish a small, meaningful piece of work: "Add title screen," "Fix typo," "Add enemy sprite." Small, frequent commits are better than one giant commit at the end of the day. They make the history easy to read and make it easy to undo just one change. This is Task 5 in U02A02 - Your First Repository - Part 1. Steps in GitHub Desktop: 1. In the Changes tab, make sure the files you want are checked. (Checked = included in this commit. This is Git's "staging area.") 2. Type a summary in the Summary box at the bottom left. It's required — the button stays gray until you type one. When the box is empty, GitHub Desktop shows gray placeholder text like "Update interests.txt." It's only a suggestion. It's too vague to be a good message, so students should write their own. What makes a good summary (the sub-bullets on the slide, and the "Good commit messages" slide in section 2): start with an action word in the present tense (Add, Fix, Update, Remove, Rename); say exactly what changed, so someone reading the History tab months later knows what happened; keep it to about 50 characters, which is a common guideline and about what fits in GitHub Desktop's History list. Extra detail ("why I changed it") goes in the optional Description box. A quick test: a good summary finishes the sentence "This commit will…" ("This commit will fix score going negative"). 3. Optional: add more detail in the Description box. 4. Click the blue "Commit to main" button. After committing, the Changes list empties, because nothing is different from your newest save point anymore. The top bar now shows "Push origin" with ↑1. The summary in the screenshot, "Change wording on interests.txt," starts with an action word and says what changed. The screenshot also shows a Copilot button (next to "New") that can write commit messages for you. In class, students should write their own — it's practice in describing their work. Image: screenshot of GitHub Desktop by Mr. Sidarous.

Push: send your local commits to the remote repository (GitHub). In GitHub Desktop, after you commit, the top-right button says "Push origin" with an up-arrow and a number — the number of commits waiting to be uploaded. Click it. When it finishes, the number disappears. Why push? - Backup: until you push, your commits only exist on this computer. - Sharing: your teacher and teammates can only see what's on GitHub. - Moving between computers: push at school, pull at home. Class rule to state clearly: Commit often. Push before you leave. How to check it worked: open the repo on github.com and refresh. Your files and your latest commit message should be there. This is Task 6 in U02A02 - Your First Repository - Part 1. Image: screenshot of GitHub Desktop by Mr. Sidarous.

Fetch: ask GitHub whether it has commits you don't have yet, and download the information about them, without changing any of your files. It's like checking your mailbox without opening the letters. In GitHub Desktop, the top-right button says "Fetch origin" when it doesn't know about anything new. Click it to check right now: - If GitHub has new commits, the button changes to "Pull origin" with a ↓ and a number. That's the next slide. - If nothing is new, it stays "Fetch origin" and you can start working. GitHub Desktop also fetches on its own in the background every so often, so the button can be out of date if someone pushed a minute ago. That's why the class routine starts with clicking Fetch. Why it matters: fetching is always safe, because it never changes your files. It tells you whether you need to pull before you start, which keeps you working on the newest version and avoids conflicts. In the terminal, this is git fetch. Under the button, GitHub Desktop says when it last checked ("Last fetched just now" in the screenshot). Before the first fetch in a repo, it says "Never fetched." Image: screenshot of GitHub Desktop by Mr. Sidarous. Sources / teaching basis: GitHub Docs, "Syncing your branch in GitHub Desktop" (docs.github.com/en/desktop), CC BY 4.0.

Pull: download new commits from the remote and update your local files. When do new commits appear on GitHub that you don't have locally? - A teammate pushed changes. - You edited a file directly on the github.com website. - You worked on another computer (home laptop) and pushed from there. In GitHub Desktop, when there are new commits on GitHub, the button says "Pull origin" with a down-arrow and a number (1 in this screenshot). Click it, and your local files update. Rule: fetch and pull before you start working. That way you're building on the newest version, and you avoid conflicts. This is Task 2 in U02AXX - Your First Repository - Part 2 (students edit the README on github.com, then pull it down). Image: screenshot of GitHub Desktop by Mr. Sidarous.

These two get confused a lot. Fetch: checks GitHub for new commits and downloads information about them, but does NOT change your files. It's like checking your mailbox without opening the letters. GitHub Desktop fetches automatically every so often, and you can click "Fetch origin" to check right now. Pull: actually brings the new commits into your local copy and updates your files. Technically, pull = fetch + merge. In GitHub Desktop the button changes on its own: it says "Fetch origin" normally. After a fetch finds new commits, it changes to "Pull origin" with a number. So the practical habit is: click Fetch; if it turns into Pull, click Pull. Sources / teaching basis: GitHub Docs, "Syncing your branch in GitHub Desktop" (docs.github.com/en/desktop), CC BY 4.0.

This is the loop to drill. Every work session: 1. Fetch — click Fetch origin to ask GitHub if there's anything new. GitHub Desktop only fetches on its own every so often, so the button may say "Fetch origin" even when GitHub has new commits. 2. Pull — if the button turns into "Pull origin" with a ↓ number, click it to get the newest version before you start. 3. Change — edit, add, or delete files. 4. Commit — save a snapshot with a message. (You can repeat Change → Commit many times in one session.) 5. Push — upload your commits before you leave. Fetch and Pull are the same button in GitHub Desktop: it says "Fetch origin" until a fetch finds new commits, then changes to "Pull origin." If nothing is new, fetch is the whole step and students move on to Change. Clone happens only once per computer per project — the first time you work on it there. Suggested classroom routine: put "Fetch → Pull → Change → Commit → Push" on the board for the first few weeks. At the end of class, ask everyone to check that their GitHub Desktop top bar does not show an ↑ number. This matches Exit ticket question 13 in U02AXX - Your First Repository - Part 2 ("Put these in the order you'd do them every day: push, fetch, change files, pull, commit").

The single most common beginner mistake, worth its own slide. Students commit, see the Changes list go empty, and think they're done. But the commit only exists on that computer. If it's a school computer that gets reset, or they go home and try to work on their laptop, the work isn't on GitHub. How to tell: in GitHub Desktop, if the top-right button shows "Push origin" with ↑ and a number, there are commits that haven't been uploaded. The screenshot shows what GitHub Desktop says right after a commit: "You have 1 local commit waiting to be pushed to GitHub." If students see that box, they haven't pushed. Mnemonic: "Commit saves it. Push sends it." Image: screenshot of GitHub Desktop by Mr. Sidarous.

One more everyday tool: undoing changes you haven't committed yet. In GitHub Desktop, right-click a file in the Changes tab and choose "Discard changes." Git throws away everything you've done to that file since your last commit and restores the committed version. It works for edits and even for deleted files — which is what students practice in Task 3 of U02AXX - Your First Repository - Part 2 (they delete their drawing on purpose, then get it back). Two important warnings: - Discard only restores what was committed. If a file was never committed, Git can't bring it back. - Treat discarding as permanent. GitHub Desktop asks you to confirm first, and its Confirm discard changes box says the changes can be restored from the Recycle Bin. But Git itself keeps no copy of uncommitted changes, so don't count on getting them back. For commits you haven't pushed yet, GitHub Desktop shows an Undo button right after you commit. For commits you already pushed, use the History tab (right-click a commit → Revert changes in commit). Students practice both in Tasks 1 and 4 of U02AXX - Your First Repository - Part 2. Image: screenshot of GitHub Desktop by Mr. Sidarous.

Think-pair-share, about 1–2 minutes. Expected answer: Fetch origin, then Pull origin (or just Pull origin if it's already showing). That brings last night's commits down to the school computer, so you're working on the newest version. Follow-up questions: - "What if you've never used this school computer for this project?" — Clone it first (File → Clone repository). - "What happens if you skip pulling, make changes, and try to push?" — GitHub will reject the push because GitHub has commits you don't have. GitHub Desktop will tell you to fetch/pull first. If the same lines were changed in both places, you might get a merge conflict (section 6). This is Check yourself question 4 in U02AXX - Your First Repository - Part 2.

Reference slide. Leave this up while students start the practice tasks, or have them copy it into their notes. Quick oral quiz: point at a random word and have a student explain it in their own words, without reading the definition. Then ask for an example of when you'd use it. If you're splitting the lesson into two days, this is a natural stopping point. Next: U02A02 - Your First Repository - Part 1 (and Part 2 on another day). After that, section 6 on collaboration.

Section 6 explains how teams use Git and GitHub to work on the same project at the same time. Students practice issues, branches, pull requests, and merging in Tasks 5–8 of U02AXX - Your First Repository - Part 2, on their own repo; merge conflicts and forks are its bonus challenges.

Set up the problem. Two students are working on the same game. Both open game.py and make changes at the same time. Without a system: - If they email files back and forth, someone's changes get overwritten. - If they use a shared folder, they might save over each other. - Nobody knows exactly what the other changed. Google Docs solves this for documents with live editing — everyone types in the same file at once. That works for essays, but not well for code: code that's half-edited by one person often doesn't run, and you don't want someone else's broken half-finished change appearing in your program while you're testing. Git's approach: everyone works on their own copy, then changes are combined (merged) in a controlled way, with a record of who changed what. The next slides show how.

A branch is a separate line of development. In this Pro Git diagram, commits C0, C1 and C2 are the main line (labeled "master," the older default name — new GitHub repos call it "main"). Two branches split off from C2: "hotfix" gets commit C4, and "iss53" (work on issue #53) gets commit C3. Each line of work moves forward on its own, and later can be merged back into the main line. Why branches? - You can work on a new feature or experiment without touching the working version on main. - Several people can each work on their own branch at the same time without interfering. - If the experiment fails, delete the branch — main was never affected. - If it works, merge it back into main. Branches in Git are cheap and fast — professionals create them constantly, often one per feature or bug fix. In GitHub Desktop, the "Current branch" button in the top bar lets you create and switch branches. Image and teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, chapter 3 "Git Branching" (figure from section 3.2, "Basic Branching and Merging"), CC BY-NC-SA 3.0. Merge (former slide): Merging takes the changes from one branch and combines them into another. Usually you merge a finished feature branch into main. Git is good at merging automatically. If Maya changed the top of game.py and Jordan changed the bottom, Git combines both sets of changes with no problem — even though they edited the same file. The diagram on this slide stops just before any merging. In Pro Git's version of the story, hotfix is merged into master first; then iss53 gets one more commit (C5) and is merged too, which makes a new "merge commit" (C6) that joins the two lines back together. On teams, merging into main usually happens through a pull request (next slide), so someone can review the changes first. Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 3.2 "Basic Branching and Merging," CC BY-NC-SA 3.0.

A pull request (PR) is a GitHub feature, not part of Git itself. It's a request to merge one branch into another, with a web page for discussion. The usual flow: 1. You make a branch and commit your changes. 2. You push the branch to GitHub and open a pull request. 3. Teammates review: they can see the diff, comment on specific lines, ask questions, and request changes. 4. Automated checks may run (tests, code style). 5. When it's approved, someone clicks "Merge pull request," and your changes join main. Why the name is confusing: you're asking the project to "pull" your changes in. Students often expect it to be called a "push request." Scale: according to Octoverse 2025, developers merged an average of 43.2 million pull requests every month on GitHub. Code review through pull requests is one of the most important professional practices: it catches bugs, spreads knowledge across the team, and helps new developers learn. The screenshots are from Task 7 of U02AXX - Your First Repository - Part 2: the top one proposes merging add-games-list into main (GitHub checks there are no conflicts: "Able to merge"); the bottom one is the button that does the merge after review. Image: screenshots of github.com by Mr. Sidarous. Sources / teaching basis: GitHub Docs, "About pull requests" (docs.github.com), CC BY 4.0. GitHub Blog, Octoverse 2025.

Most of the time Git merges automatically. A merge conflict happens when two changes touch the same lines of the same file in different ways, and Git can't know which one is right. Example: Maya changes line 10 to `speed = 5` and Jordan changes the same line to `speed = 8`. Git stops and marks the conflict in the file, showing both versions. A person has to decide: keep Maya's, keep Jordan's, or write something new. Then they commit the resolved version. Key messages for students: - Conflicts are normal, not a disaster. Professionals deal with them regularly. - Nothing is lost — Git shows you both versions. - Prevent most conflicts by pulling often, committing small changes, and talking to your team about who's working on which files. GitHub Desktop helps resolve conflicts: it lists conflicted files and offers to open them in your editor, and some editors (like VS Code) have buttons for "Accept current change" / "Accept incoming change." Sources / teaching basis: Scott Chacon and Ben Straub, Pro Git, 2nd edition, section 3.2 "Basic Merge Conflicts," CC BY-NC-SA 3.0.

A fork is a copy of another person's repository, made under your own GitHub account. Forks are a GitHub feature. Fork vs. clone: - Fork: copies a repo from someone else's GitHub account to your GitHub account (on GitHub's servers). - Clone: copies a repo from GitHub to your computer. You often do both: fork the project on GitHub, then clone your fork to your computer. Why fork? You usually don't have permission to push to someone else's project. With a fork, you can make any changes you want in your own copy. If you want to contribute back, you open a pull request from your fork to the original project. The original owners decide whether to merge it. This is how open source works: anyone in the world can fork a project like VS Code, fix a bug, and propose the fix. In class, GitHub Classroom assignments often work in a similar way: each student gets their own copy of a starter repository. Sources / teaching basis: GitHub Docs, "About forks" and "Cloning and forking repositories from GitHub Desktop" (docs.github.com), CC BY 4.0. The screenshot shows where the Fork button is: at the top right of every repo page, next to Watch and Star. The number after it counts how many forks exist. Image: screenshot of github.com by Mr. Sidarous.

Issues are GitHub's built-in task tracker. Each repository has an Issues tab where anyone with access can: - Report a bug: "The game crashes when you press space twice." - Suggest a feature: "Add a pause menu." - Track tasks: "Write the README." Each issue can be assigned to a person, labeled (bug, enhancement, good first issue), discussed in comments, and closed when it's done. Pull requests can be linked to issues — writing "Fixes #12" in a pull request automatically closes issue #12 when the PR is merged. For student group projects: issues are a great way to divide work. Each team member takes an issue, makes a branch, and opens a pull request when done. The screenshot is a real bug report in a practice repo. Point out what makes it useful: a title that says what's wrong ("Bug: …"), a Description of the problem, and the Expected behavior. Anyone on the team could pick it up and know what to fix. The description uses Markdown (## makes a heading, - makes a bullet), and the Preview tab shows how it will look. Students create their own issue in Task 5 of U02AXX - Your First Repository - Part 2. Image: screenshot of github.com by Mr. Sidarous.

This puts the collaboration pieces together into the workflow many professional teams use (often called "GitHub flow"): 1. Issue — someone describes a bug or feature. 2. Branch — a developer creates a branch for that work. 3. Commits — they make changes and commit, pushing the branch to GitHub. 4. Pull request — they open a PR; teammates review and discuss; automated tests run. 5. Merge — once approved, the PR is merged into main, and the issue closes. Then everyone pulls the updated main and the cycle continues. You can map this to a student group project: the team lists tasks as issues, each member takes one, works on a branch, and opens a PR that a teammate reviews before merging. Sources / teaching basis: GitHub Docs, "GitHub flow" (docs.github.com/en/get-started/using-github/github-flow), CC BY 4.0.

Reference slide for section 6. Same quick oral quiz as before: point at a word, have a student explain it in their own words and give an example. Common confusions to check: - Fork vs. clone (GitHub → your GitHub, vs. GitHub → your computer). - Pull vs. pull request (download commits, vs. ask someone to merge your branch). - Merge vs. merge conflict (combining changes, vs. the case where Git needs a human to decide).

Review activity for the whole deck. Have students answer on paper or mini whiteboards, then reveal. Answers: - Start work on a new computer → Clone (then fetch and pull in future sessions). - Finished a small piece of work → Commit (with a good message). - Messed up a file you haven't committed → Discard (right-click it in Changes). - Leaving class → Push. - Check whether GitHub has anything new → Fetch. - GitHub has new commits; get them → Pull. - Try a risky idea safely → Branch. - Want a teammate to review your code → Pull request. - Found a bug in a teammate's game → Issue. Bonus questions: - "You and a teammate changed the same line." → Merge conflict; decide together which version to keep. - "You want to suggest a fix to an open source project you don't own." → Fork, change, pull request. - "You pushed a commit with a mistake in it." → Revert it in the History tab, then push.

Summary. Reveal one at a time and have students say each one out loud with you. Exit ticket ideas (pick one or two): 1. In one sentence each, explain Git, GitHub, and GitHub Desktop. 2. What's the difference between commit and push? 3. Name one reason version control is useful for a team project. 4. Write a good commit message for: "You added a background image to your website." Next steps: - If students don't have accounts yet: U02A01 - Creating your GitHub Account. - Hands-on practice, Part 1: U02A02 - Your First Repository - Part 1 (create a repo, clone it, add a text file and a picture, commit, push). - Quiz: U02A03 - GitHub Quiz (a Google Form on the whole deck). - Processing practice: U02A04 - Draw Your Game Character (a first sketch in a new repo, committed after each step). - Hands-on practice, Part 2: U02AXX - Your First Repository - Part 2 (see changes, undo, pull, discard, revert, issue, branch, pull request, merge, make it public).

Transition to the hands-on practice. Students should have: - A GitHub account (U02A01 - Creating your GitHub Account, steps 1–4). - GitHub Desktop signed in (U02A01 - Creating your GitHub Account, step 5). Then they follow U02A02 - Your First Repository - Part 1 (Tasks 1–6, about 30 minutes), then the quiz, U02A03 - GitHub Quiz (after section 6, since it covers the whole deck), U02A04 - Draw Your Game Character (about 60 minutes, two class days), and U02A05 - Code Detective (about 50 minutes). Part 2 (U02AXX - Your First Repository - Part 2, about 50 minutes) takes two class days: Tasks 1–4 after section 5, and Tasks 5–9 after section 6. Circulate and watch for the most common problems: files saved outside the repo folder, committing without pushing, and repos not showing in the Clone list (usually a refresh or sign-in issue). Image and content credits for this deck: - Diagrams (snapshots over time, distributed version control, branching): Scott Chacon and Ben Straub, Pro Git, 2nd edition (git-scm.com/book), licensed CC BY-NC-SA 3.0. - github.com screenshots (Private label, Issues, Fork button): Mr. Sidarous's own. - GitHub Desktop screenshots: Mr. Sidarous's own. - Git in a terminal: made for this deck from real Git output. - Statistics: GitHub Octoverse 2025 (github.blog/news-insights/octoverse/); Stack Overflow Blog, "Beyond Git," January 2023 (2022 Developer Survey); Microsoft News Center, June 4, 2018.

Reference slide for the whole deck: every word from sections 4–6 on one page. Leave it up while students work on the practice handouts, or print it as a word wall. Quick oral quiz: point at a word and have a student explain it in their own words and give an example from their own repo. Common confusions to check: - Git vs. GitHub (the tool on your computer, vs. the website that hosts repos). - Fetch vs. pull (check for new commits, vs. download them and update your files). - Commit vs. push (save on your computer, vs. upload to GitHub). - Clone vs. fork (GitHub → your computer, vs. someone else's GitHub → your GitHub). - Pull vs. pull request (download commits, vs. ask someone to merge your branch).