Introduction to Version Control (Git)

Active learning works for version control because Git commands are procedural skills that students can only master by doing. The topic demands immediate, hands-on practice to turn abstract ideas like staging and committing into muscle memory.

• 9th Grade
• Computer Science
• 4 activities
• 15 min–40 min

Learning Objectives

1. Demonstrate the use of Git commands (init, add, commit, status, push, pull) to manage a local code repository.
2. Explain how a commit history in Git prevents data loss and facilitates code recovery.
3. Compare the functionality of Git with manual file-saving strategies for tracking project changes.
4. Construct a basic Git workflow for tracking changes in an individual programming project.

Stations Rotation

⏱ 40 min·Individual

Hands-On Lab: First Git Workflow

Students follow a guided sequence to initialize a repository, create a text file, stage changes with git add, commit with a descriptive message, and view the log with git log. After completing the sequence, they make a second change and practice the add-commit cycle again, reinforcing that commits are intentional checkpoints.

Prepare & details

Explain how version control systems prevent data loss in collaborative environments.

Facilitation Tip: During the First Git Workflow lab, circulate to ensure students physically type each command rather than copy-pasting, so they experience the syntax firsthand.

Setup: Tables/desks arranged in 4-6 distinct stations around room

Materials: Station instruction cards, Different materials per station, Rotation timer

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Think-Pair-Share

⏱ 15 min·Pairs

Think-Pair-Share: What Gets Committed?

Show students a diff between two versions of a short code file and ask them to write a meaningful commit message for the change. Partners compare their messages and discuss what information a good commit message should convey and for whom.

Prepare & details

Differentiate between common Git commands (e.g., commit, push, pull).

Facilitation Tip: For the What Gets Committed? think-pair-share, ask students to explain their reasoning to a partner before sharing with the class, which strengthens conceptual clarity.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Simulation Game

⏱ 35 min·Small Groups

Simulation Game: Recovering from a Mistake

Instructor introduces a deliberate error to a shared repository (deletes a key function). Small groups must use git log and git checkout to identify when the file was last correct and restore it. Groups document the steps they used and share one 'lesson learned' with the class.

Prepare & details

Construct a basic Git workflow for individual project management.

Facilitation Tip: In the Recovering from a Mistake simulation, give students exactly 5 minutes to recover the file, mimicking the pressure of real-world deadlines.

Setup: Flexible space for group stations

Materials: Role cards with goals/resources, Game currency or tokens, Round tracker

• Apply
• Analyze
• Evaluate
• Create
• Social Awareness
• Decision-Making

Gallery Walk

⏱ 25 min·Small Groups

Gallery Walk: Git Command Reference

Post six stations around the room, each with a Git command (commit, push, pull, status, log, clone). Students rotate and write a plain-English explanation of what each command does and when they would use it. Class compares explanations and builds a shared reference card.

Prepare & details

Explain how version control systems prevent data loss in collaborative environments.

Facilitation Tip: At each Gallery Walk station, ask students to write one command they still find confusing, so you can address it in the next class.

Setup: Wall space or tables arranged around room perimeter

Materials: Large paper/poster boards, Markers, Sticky notes for feedback

• Understand
• Apply
• Analyze
• Create
• Relationship Skills
• Social Awareness

Teaching This Topic

Teach version control by starting with small, frequent commits so students see Git as a daily habit rather than an overwhelming system. Use real-world analogies like saving levels in a video game to make the concept relatable. Avoid overwhelming students with advanced commands early; focus on mastering the basics first, as research shows procedural skills build gradually with practice.

What to Expect

By the end of these activities, students will confidently execute Git commands, explain the difference between saving and committing, and use Git to recover from mistakes. They will also articulate why version control is useful even for small projects.

Watch Out for These Misconceptions

Common Misconception

During the First Git Workflow lab, watch for students who assume saving a file in their editor automatically updates Git.

What to Teach Instead

Pause the lab and have students open their Git status output to show that saved files appear as untracked. Ask them to run `git add` explicitly to move the file to the staging area, reinforcing the distinction between saving and committing.

Common Misconception

During the What Gets Committed? think-pair-share, watch for students who believe all files should be committed together.

What to Teach Instead

Provide a partially completed project folder with a mix of files and ask students to decide which files belong in a commit. Have them justify their choices in pairs, then reveal the correct selections as a class.

Common Misconception

During the Recovering from a Mistake simulation, watch for students who think pushing to a remote repository is irreversible.

What to Teach Instead

After the simulation, ask students to explain how `git revert` and `git restore` differ from deleting files. Have them demonstrate recovery on a volunteer’s terminal to solidify the concept.

Assessment Ideas

Exit Ticket

After the First Git Workflow lab, provide students with a scenario: 'You just fixed a bug in your program. What are the next three Git commands you would run to save this work and share it with your team?' Students write the commands and a brief explanation for each.

Quick Check

During the What Gets Committed? think-pair-share, ask students to perform a specific Git action: 'Create a new file, stage it, and commit it with the message 'Initial setup'.' Observe students’ terminal output to confirm they used the correct commands.

Discussion Prompt

After the Recovering from a Mistake simulation, pose the question: 'Imagine you accidentally deleted a crucial file. How could Git help you recover it?' Facilitate a class discussion where students explain the role of the commit history in restoring lost work, referencing commands like `git log` and `git checkout`.

Extensions & Scaffolding

• Challenge early finishers to create a branch, make a change, and merge it back, demonstrating how branches support parallel work.
• Scaffolding: Provide a printed cheat sheet of the most common Git commands for students who struggle with recall during the First Git Workflow lab.
• Deeper exploration: Have students research and present one advanced Git feature like rebasing or stashing, connecting it to their daily work.

Key Vocabulary

Repository (Repo)	A storage location for a project's files and its complete version history. It's like a project's timeline.
Commit	A snapshot of your project at a specific point in time. Each commit has a unique message describing the changes made.
Staging Area	An intermediate area where you prepare changes before committing them. It allows you to select specific modifications to include in the next commit.
Push	The action of uploading your local commits to a remote repository, sharing your changes with others or backing them up online.
Pull	The action of downloading changes from a remote repository to your local machine, updating your project with contributions from others.