Computer Science · 9th Grade

Active learning ideas

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.

• Common Core State Standards
• CSTA: 3A-AP-22

• 15–40 min
• Pairs → Whole Class
• 4 activities

Activity 01

• 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.

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.

What to look for

Provide students with a scenario: 'You just finished adding a new feature to your project. What are the next three Git commands you would use to save this work and share it?' Students write the commands and a brief explanation for each.

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

Activity 02

• 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.

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.

What to look for

Ask students to perform a specific Git action, such as 'Create a new file, add it to the staging area, and commit it with the message 'Initial setup'.' Observe students' screens or ask them to show their terminal output to confirm they used the correct commands.

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

Activity 03

• 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.

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.

What to look for

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.

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

Activity 04

• 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.

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.

What to look for

Provide students with a scenario: 'You just finished adding a new feature to your project. What are the next three Git commands you would use to save this work and share it?' Students write the commands and a brief explanation for each.

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

A few notes on teaching this unit

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.

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

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

  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.

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

  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.

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

  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.

---

Methods used in this brief

• Stations Rotation
• Think-Pair-Share
• Simulation Game
• Gallery Walk