Hands-on lab — Day 29: Why Version Control Exists

#!/usr/bin/env bash
# Day 029 lab — completed reference implementation.
#
# Builds a THROWAWAY git repository in a temporary directory, makes three
# commits to a single file, then shows the history four ways:
#   1. git log --oneline   (the shelf of snapshots)
#   2. git diff            (what changed between two commits)
#   3. git show            (the full detail of one commit)
#   4. restore an earlier version (the "time machine")
# It sets a LOCAL git identity inside the temp repo only, so it works even
# if you have never configured git globally, and it deletes the temporary
# directory on exit (including on Ctrl-C) so nothing is left behind.
#
# Local only: no network is used at any point.
set -euo pipefail

# --- create a throwaway working area, and guarantee cleanup on exit ---------
tmp_dir="$(mktemp -d "${TMPDIR:-/tmp}/day029-vcs-demo.XXXXXX")"
cleanup() {
  echo
  echo "Cleaning up the temporary repository..."
  rm -rf "${tmp_dir}"
  echo "Done. Nothing left behind."
}
trap cleanup EXIT

echo "=== Version control history demo ==="
echo "Creating a throwaway repository in a temporary directory..."
echo "(temporary directory: ${tmp_dir})"

cd "${tmp_dir}"

# --- initialize the repository and set a LOCAL identity ---------------------
# --initial-branch keeps output stable across git versions; the identity is
# scoped to THIS repo only (no --global), so your machine's config is untouched.
git init --quiet --initial-branch=main
git config user.name "Course Learner"
git config user.email "learner@example.com"

# --- commit 1 ---------------------------------------------------------------
printf 'Point one: version control keeps history.\n' > notes.txt
git add notes.txt
git commit --quiet -m "Start notes with a first point"
c1="$(git rev-parse HEAD)"
echo "Made commit 1: Start notes with a first point"

# --- commit 2 ---------------------------------------------------------------
printf 'Point two: every commit records who, when, and why.\n' >> notes.txt
git add notes.txt
git commit --quiet -m "Expand the notes with a second point"
c2="$(git rev-parse HEAD)"
echo "Made commit 2: Expand the notes with a second point"

# --- commit 3 ---------------------------------------------------------------
printf 'Closing line: nothing committed is ever truly lost.\n' >> notes.txt
git add notes.txt
git commit --quiet -m "Add a closing line to the notes"
echo "Made commit 3: Add a closing line to the notes"

# --- view 1: the one-line log ----------------------------------------------
echo
echo "--- git log --oneline (newest first) ---"
git log --oneline

# --- view 2: a diff between commit 1 and commit 2 ---------------------------
echo
echo "--- git diff between commit 1 and commit 2 (notes.txt) ---"
# Show only the added/removed content lines to keep the demo readable.
git diff "${c1}" "${c2}" -- notes.txt | grep -E '^[+-][^+-]' || true

# --- view 3: the full detail of commit 2 -----------------------------------
echo
echo "--- git show of commit 2 ---"
git show --no-patch --format='Author: %an <%ae>%n    %s' "${c2}"

# --- view 4: the time machine — restore notes.txt to commit 1 ---------------
echo
echo "--- Time machine: restoring notes.txt to commit 1 ---"
# 'git restore' (git >= 2.23) is preferred; fall back to 'git checkout' if the
# installed git is older, so the demo works everywhere.
if git restore --source="${c1}" -- notes.txt 2>/dev/null; then
  :
else
  git checkout "${c1}" -- notes.txt
fi
echo "Restored. notes.txt now reads:"
cat notes.txt

# cleanup runs automatically via the EXIT trap.

lesson_id: D029
day: 29
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-029-why-version-control-exists
run_commands:
  - bash examples/history_demo.sh
  - bash starter/history_demo.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - '# none needed: each script deletes its own temporary directory on exit'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), git 2.50.1, bash tests/run_tests.sh → 12 checks, 0 failure(s).'

# Dependencies — Day 029 lab

**Just `git` and a POSIX shell.** This lab has no installable project
dependencies and needs no network, account, or API key.

- `bash` (3.2 or newer — preinstalled on macOS and every mainstream Linux
  distribution).
- `git` (2.x). Checking whether you already have it:

  ```bash
  git --version
  ```

If that prints a version, you are ready. If it says `command not found`,
install git — it is free and open source on every platform:

- **macOS:** ships with the Command Line Tools. Install them with
  `xcode-select --install`, or install git via Homebrew: `brew install git`.
- **Debian/Ubuntu Linux:** `sudo apt update && sudo apt install git`
- **Fedora/RHEL Linux:** `sudo dnf install git`
- **Windows:** install Git for Windows (which includes Git Bash), or run the
  lab inside WSL and use the Linux instructions.

Standard utilities the scripts use — `mktemp`, `printf`, `cat`, `grep`,
`sed`, `awk` — are part of the base system on macOS and Linux. `git restore`
needs git 2.23 or newer; on older git the scripts fall back to `git checkout`
automatically, so any 2.x release works.

#!/usr/bin/env bash
# Day 029 lab — YOUR working file.
#
# The repository-building part is done for you: this script creates a
# THROWAWAY git repo in a temporary directory, sets a LOCAL identity, makes
# three commits to notes.txt, and cleans up on exit. Your job is the four
# numbered exercises below — each names the EXACT git command to run so you
# can inspect the history you built. Replace each 'echo "FILL-IN ..."' line with
# the command named in the comment above it, then run:
#
#   bash starter/history_demo.sh
#
# The completed reference version is examples/history_demo.sh — try it
# yourself first, then come back and fill these in.
#
# Local only: no network is used at any point.
set -euo pipefail

tmp_dir="$(mktemp -d "${TMPDIR:-/tmp}/day029-vcs-demo.XXXXXX")"
cleanup() {
  echo
  echo "Cleaning up the temporary repository..."
  rm -rf "${tmp_dir}"
  echo "Done. Nothing left behind."
}
trap cleanup EXIT

echo "=== Version control history demo (starter) ==="
echo "Creating a throwaway repository in a temporary directory..."
echo "(temporary directory: ${tmp_dir})"

cd "${tmp_dir}"

git init --quiet --initial-branch=main
git config user.name "Course Learner"
git config user.email "learner@example.com"

printf 'Point one: version control keeps history.\n' > notes.txt
git add notes.txt
git commit --quiet -m "Start notes with a first point"
c1="$(git rev-parse HEAD)"
echo "Made commit 1: Start notes with a first point"

printf 'Point two: every commit records who, when, and why.\n' >> notes.txt
git add notes.txt
git commit --quiet -m "Expand the notes with a second point"
c2="$(git rev-parse HEAD)"
echo "Made commit 2: Expand the notes with a second point"

printf 'Closing line: nothing committed is ever truly lost.\n' >> notes.txt
git add notes.txt
git commit --quiet -m "Add a closing line to the notes"
echo "Made commit 3: Add a closing line to the notes"

# =====================  YOUR EXERCISES  =====================================

# --- Exercise 1: show the one-line history -------------------------------
# Replace the FILL-IN line with the command:   git log --oneline
echo
echo "--- Exercise 1: git log --oneline (newest first) ---"
echo "FILL-IN Exercise 1: run 'git log --oneline'"

# --- Exercise 2: diff commit 1 against commit 2 --------------------------
# The commit ids are already saved in ${c1} and ${c2}. Replace the FILL-IN with:
#   git diff "${c1}" "${c2}" -- notes.txt
echo
echo "--- Exercise 2: git diff between commit 1 and commit 2 (notes.txt) ---"
echo "FILL-IN Exercise 2: run 'git diff \"\${c1}\" \"\${c2}\" -- notes.txt'"

# --- Exercise 3: show the full detail of commit 2 ------------------------
# Replace the FILL-IN with:   git show "${c2}"
echo
echo "--- Exercise 3: git show of commit 2 ---"
echo "FILL-IN Exercise 3: run 'git show \"\${c2}\"'"

# --- Exercise 4: time machine — restore notes.txt to commit 1 ------------
# Replace the FILL-IN with (git 2.23+):   git restore --source="${c1}" -- notes.txt
# On older git, use instead:           git checkout "${c1}" -- notes.txt
echo
echo "--- Exercise 4: restore notes.txt to commit 1 ---"
echo "FILL-IN Exercise 4: run 'git restore --source=\"\${c1}\" -- notes.txt'"
echo "notes.txt now reads:"
cat notes.txt

# cleanup runs automatically via the EXIT trap.

# Version control worksheet — Day 29

Fill this in after running `bash examples/history_demo.sh`. Answer in your own
words; there are no trick questions.

## 1. How many commits did the demo make, and what did each one do?

Number of commits: ____________

- Commit 1 did: ______________________________________________________
- Commit 2 did: ______________________________________________________
- Commit 3 did: ______________________________________________________

## 2. What did `git log --oneline` show?

Paste the three lines from your own run (the short id + message for each
commit, newest first):

```text
________________________________________
________________________________________
________________________________________
```

Why are your commit ids different from the ones in the lesson's sample?
(One sentence.)

____________________________________________________________________

## 3. One thing version control can recover that plain file copies cannot

Name one specific thing you could recover or answer using this history that
you could NOT get from a folder of dated copies like `notes_v1.txt`,
`notes_v2.txt` — for example: the exact author and reason behind a single
changed line, a precise line-by-line diff between two versions, or a clean
restore of one file without disturbing the others.

____________________________________________________________________

____________________________________________________________________

## 4. In one sentence: what problem does version control solve for a team?

____________________________________________________________________

#!/usr/bin/env bash
# Tests for the Day 029 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the reference demo:
#   - builds a repository with exactly three commits,
#   - shows a diff (an added line) between two commits,
#   - restores an earlier version (the time machine), and
#   - cleans up its temporary directory, leaving nothing behind.
# Also checks the starter file names the four required git commands.
# No network is used.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
demo="${lab_dir}/examples/history_demo.sh"
starter="${lab_dir}/starter/history_demo.sh"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# --- git must be available --------------------------------------------------
if ! command -v git >/dev/null 2>&1; then
  echo "FAIL: git is not installed — see requirements/README.md"
  exit 1
fi

echo "Testing ${demo} ..."
if ! output="$(bash "${demo}" 2>&1)"; then
  check "demo script exits successfully" "no"
  echo "${output}" | sed 's/^/    /'
  echo
  echo "${checks} checks, ${failures} failure(s)."
  exit 1
fi
check "demo script exits successfully" "yes"

# Three commits were made.
made_count="$(printf '%s\n' "${output}" | grep -c '^Made commit [123]:')"
[ "${made_count}" -eq 3 ] && check "demo reports three commits made" "yes" || check "demo reports three commits made" "no"

# git log --oneline showed three commit lines (between its header and the next blank line).
log_count="$(printf '%s\n' "${output}" | awk '/^--- git log --oneline/{f=1;next} /^$/{f=0} f' | grep -c '.')"
[ "${log_count}" -eq 3 ] && check "git log --oneline lists three commits" "yes" || check "git log --oneline lists three commits" "no"

# A diff was shown: the added second-point line appears with a leading '+'.
printf '%s\n' "${output}" | grep -q '^+Point two:' && check "a diff shows an added line between two commits" "yes" || check "a diff shows an added line between two commits" "no"

# git show revealed an author line.
printf '%s\n' "${output}" | grep -q '^Author: Course Learner' && check "git show reveals the commit author" "yes" || check "git show reveals the commit author" "no"

# The time machine restored commit 1's content.
printf '%s\n' "${output}" | grep -q '^Point one: version control keeps history\.$' && check "restore brings back commit 1's version" "yes" || check "restore brings back commit 1's version" "no"

# Cleanup ran and the temporary directory it named no longer exists.
printf '%s\n' "${output}" | grep -q '^Done\. Nothing left behind\.$' && check "demo prints its cleanup confirmation" "yes" || check "demo prints its cleanup confirmation" "no"
tmp_path="$(printf '%s\n' "${output}" | sed -n 's/^(temporary directory: \(.*\))$/\1/p')"
if [ -n "${tmp_path}" ] && [ ! -e "${tmp_path}" ]; then
  check "temporary directory is gone after the run" "yes"
elif [ -z "${tmp_path}" ]; then
  check "temporary directory path was reported" "no"
else
  check "temporary directory is gone after the run" "no"
fi

# --- starter names the four required git commands ---------------------------
echo "Testing ${starter} ..."
for cmd in "git log --oneline" "git diff" "git show" "git restore"; do
  grep -q "${cmd}" "${starter}" && check "starter names '${cmd}'" "yes" || check "starter names '${cmd}'" "no"
done

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]