Hands-on lab — Day 42: Section Review: Your Computing Foundations Toolkit

#!/usr/bin/env bash
# Day 042 lab — Computing Foundations Toolkit Check (completed reference).
#
# A capstone for Course 1: it inspects your own machine for the core tools
# you learned across days 1-41, reports each tool's version and the day that
# taught it, then runs three live skill checks that exercise skills from
# across the section (make a git repo, run a shell pipeline, query SQLite).
# It is read-only on your real files, needs no network, and degrades
# gracefully when a tool is missing — telling you which day covers it.
#
# Usage:  bash examples/toolkit_check.sh
set -uo pipefail

os="$(uname -s)"
tools_present=0
tools_total=0
skills_passed=0
skills_total=0

echo "=== Computing Foundations Toolkit Check ==="
echo "Generated on: $(date '+%Y-%m-%d')"
echo "Operating system kernel: ${os}"
echo
echo "-- Tool inventory --"

# report_tool <label> <version-string-or-empty> <maps-to-note>
report_tool() {
  local label="$1" version="$2" note="$3"
  tools_total=$((tools_total + 1))
  if [ -n "${version}" ]; then
    tools_present=$((tools_present + 1))
    printf '[ok]   %-9s : %s (%s)\n' "${label}" "${version}" "${note}"
  else
    printf '[--]   %-9s : not found — %s\n' "${label}" "${note}"
  fi
}

# --- shell (Day 8) ---
shell_path="${SHELL:-}"
[ -z "${shell_path}" ] && shell_path="$(command -v bash || true)"
report_tool "shell" "${shell_path}" "maps to Day 8: Meet the Terminal"

# --- git (Day 30) ---
if command -v git >/dev/null 2>&1; then
  report_tool "git" "$(git --version)" "maps to Day 30: Git Fundamentals"
else
  report_tool "git" "" "maps to Day 30: Git Fundamentals — install git to continue the course"
fi

# --- curl (Day 21) ---
if command -v curl >/dev/null 2>&1; then
  report_tool "curl" "$(curl --version 2>/dev/null | head -n 1 | cut -d' ' -f1-2)" "maps to Day 21: Inspecting Traffic with curl"
else
  report_tool "curl" "" "maps to Day 21: Inspecting Traffic with curl"
fi

# --- python3 (used across the course from Day 15 on) ---
if command -v python3 >/dev/null 2>&1; then
  report_tool "python3" "$(python3 --version 2>&1)" "maps to Day 15+: used across the course"
else
  report_tool "python3" "" "maps to Day 15+: install python3 before Course 2"
fi

# --- sqlite3 (Day 39) ---
if command -v sqlite3 >/dev/null 2>&1; then
  report_tool "sqlite3" "$(sqlite3 --version 2>/dev/null | cut -d' ' -f1)" "maps to Day 39: Data Storage"
else
  report_tool "sqlite3" "" "maps to Day 39: Data Storage — brew/apt install sqlite3"
fi

# --- editor (Day 36): prefer $EDITOR, else look for a common one ---
editor_found=""
if [ -n "${EDITOR:-}" ]; then
  editor_found="\$EDITOR=${EDITOR}"
else
  for e in nvim vim nano code emacs micro; do
    if command -v "${e}" >/dev/null 2>&1; then
      editor_found="found ${e} on PATH (\$EDITOR unset)"
      break
    fi
  done
fi
report_tool "editor" "${editor_found}" "maps to Day 36: Choosing an Editor"

echo
echo "-- Skill checks --"

# skill_result <label> <ok:yes/no> <days>
skill_result() {
  local label="$1" ok="$2" days="$3"
  skills_total=$((skills_total + 1))
  if [ "${ok}" = "yes" ]; then
    skills_passed=$((skills_passed + 1))
    printf '[ok]   %-30s (%s)\n' "${label}" "${days}"
  else
    printf '[--]   %-30s (%s)\n' "${label}" "${days}"
  fi
}

# Skill 1: version control — init a throwaway repo and commit (Days 29-30).
git_skill="no"
if command -v git >/dev/null 2>&1; then
  tmp_repo="$(mktemp -d "${TMPDIR:-/tmp}/toolkit-check-tmp.XXXXXX")"
  if (
    cd "${tmp_repo}" &&
    git init -q &&
    echo "hello foundations" > note.txt &&
    git add note.txt &&
    git -c user.name='Toolkit Check' -c user.email='check@example.com' commit -q -m 'first commit' &&
    git log --oneline | grep -q 'first commit'
  ) >/dev/null 2>&1; then
    git_skill="yes"
  fi
  rm -rf "${tmp_repo}"
fi
skill_result "git init + commit works" "${git_skill}" "Days 29-30"

# Skill 2: the command line — build a pipeline and count matching lines (Days 10-12).
pipe_skill="no"
count="$(printf 'apple\nbanana\napricot\ncherry\n' | grep '^a' | wc -l | tr -d ' ')"
[ "${count}" = "2" ] && pipe_skill="yes"
skill_result "shell pipeline works" "${pipe_skill}" "Days 10-12"

# Skill 3: storage — create and query an in-memory SQLite table (Day 39).
sql_skill="no"
if command -v sqlite3 >/dev/null 2>&1; then
  answer="$(sqlite3 ':memory:' 'CREATE TABLE t(x INTEGER); INSERT INTO t VALUES (42); SELECT x FROM t;' 2>/dev/null)"
  [ "${answer}" = "42" ] && sql_skill="yes"
fi
skill_result "sqlite query works" "${sql_skill}" "Day 39"

echo
echo "-- Readiness --"
echo "Tools present: ${tools_present} / ${tools_total}   Skills passed: ${skills_passed} / ${skills_total}"

# Core tools that Course 2 truly needs: git, python3, and a shell + pipeline.
if [ "${git_skill}" = "yes" ] && [ "${pipe_skill}" = "yes" ] && command -v python3 >/dev/null 2>&1; then
  echo "You are ready for Course 2. Nice work finishing the foundations."
else
  echo "Almost there — revisit the day(s) shown next to any [--] line above, then re-run."
fi
echo "=== End of check ==="

lesson_id: D042
day: 42
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-042-section-review-your-computing-foundations-toolkit
run_commands:
  - bash examples/toolkit_check.sh
  - bash starter/toolkit_check.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/toolkit_check.sh  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), bash tests/run_tests.sh → 22 checks, 0 failure(s).'

# Dependencies — Day 042 lab

This lab checks for the core Course 1 toolkit on your machine; it does not
install anything. The check itself needs only a POSIX shell:

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution)
- Standard utilities the check calls: `uname`, `date`, `command`, `mktemp`,
  `printf`, `grep`, `wc`, `tr` — all part of the base system.

The tools the check *looks for* are the section's toolkit. They are not
required for the script to run (it degrades gracefully when one is missing),
but you will want them for the rest of the course:

| Tool | Course 1 day | Install if missing |
| ---- | ------------- | ------------------ |
| a shell | Day 8 | Already present — it is running the script |
| `git` | Days 29-35 | `brew install git` / `apt install git` (Day 13 covered package managers) |
| `curl` | Day 21 | `brew install curl` / `apt install curl` |
| `python3` | Day 15+ | `brew install python` / `apt install python3` |
| `sqlite3` | Day 39 | `brew install sqlite` / `apt install sqlite3` |
| an editor | Day 36 | `brew install vim`/`nano`, or set `$EDITOR` |

There is deliberately no `requirements.txt`/`package.json`: this capstone
must run on any machine that finished Course 1, including one with gaps.

#!/usr/bin/env bash
# Day 042 lab — Computing Foundations Toolkit Check (YOUR working file).
#
# This starter already prints the report skeleton and detects your OS. Your
# job is the four numbered exercises below: each names the exact command to
# fill in, replacing the `FILL_ME_IN` placeholder. The completed reference is
# in examples/toolkit_check.sh — run that first, then rebuild these four
# pieces yourself. The script is read-only on your real files and needs no
# network.
#
# Usage:  bash starter/toolkit_check.sh
set -uo pipefail

os="$(uname -s)"
tools_present=0
tools_total=0
skills_passed=0
skills_total=0

echo "=== Computing Foundations Toolkit Check ==="
echo "Generated on: $(date '+%Y-%m-%d')"
echo "Operating system kernel: ${os}"
echo
echo "-- Tool inventory --"

report_tool() {
  local label="$1" version="$2" note="$3"
  tools_total=$((tools_total + 1))
  if [ -n "${version}" ]; then
    tools_present=$((tools_present + 1))
    printf '[ok]   %-9s : %s (%s)\n' "${label}" "${version}" "${note}"
  else
    printf '[--]   %-9s : not found — %s\n' "${label}" "${note}"
  fi
}

# --- shell (already done for you, as a worked example) ---
shell_path="${SHELL:-}"
[ -z "${shell_path}" ] && shell_path="$(command -v bash || true)"
report_tool "shell" "${shell_path}" "maps to Day 8: Meet the Terminal"

# ===========================================================================
# Exercise 1: report the git version.
#   Replace FILL_ME_IN with the command that prints git's version:
#       git --version
#   Keep it inside the "$(...)" so its output becomes the version string.
# ===========================================================================
if command -v git >/dev/null 2>&1; then
  git_version="$(FILL_ME_IN)"
  report_tool "git" "${git_version}" "maps to Day 30: Git Fundamentals"
else
  report_tool "git" "" "maps to Day 30: Git Fundamentals — install git to continue"
fi

# --- curl, python3, sqlite3, editor (done for you) ---
if command -v curl >/dev/null 2>&1; then
  report_tool "curl" "$(curl --version 2>/dev/null | head -n 1 | cut -d' ' -f1-2)" "maps to Day 21: Inspecting Traffic with curl"
else
  report_tool "curl" "" "maps to Day 21: Inspecting Traffic with curl"
fi
if command -v python3 >/dev/null 2>&1; then
  report_tool "python3" "$(python3 --version 2>&1)" "maps to Day 15+: used across the course"
else
  report_tool "python3" "" "maps to Day 15+: install python3 before Course 2"
fi
if command -v sqlite3 >/dev/null 2>&1; then
  report_tool "sqlite3" "$(sqlite3 --version 2>/dev/null | cut -d' ' -f1)" "maps to Day 39: Data Storage"
else
  report_tool "sqlite3" "" "maps to Day 39: Data Storage — brew/apt install sqlite3"
fi
editor_found=""
if [ -n "${EDITOR:-}" ]; then
  editor_found="\$EDITOR=${EDITOR}"
else
  for e in nvim vim nano code emacs micro; do
    if command -v "${e}" >/dev/null 2>&1; then
      editor_found="found ${e} on PATH (\$EDITOR unset)"
      break
    fi
  done
fi
report_tool "editor" "${editor_found}" "maps to Day 36: Choosing an Editor"

echo
echo "-- Skill checks --"

skill_result() {
  local label="$1" ok="$2" days="$3"
  skills_total=$((skills_total + 1))
  if [ "${ok}" = "yes" ]; then
    skills_passed=$((skills_passed + 1))
    printf '[ok]   %-30s (%s)\n' "${label}" "${days}"
  else
    printf '[--]   %-30s (%s)\n' "${label}" "${days}"
  fi
}

# ===========================================================================
# Exercise 2: verify git works by making a throwaway repo and committing.
#   Fill the two placeholder lines inside the subshell:
#     - initialise a repo quietly:   git init -q
#     - commit the staged file:      git -c user.name='Toolkit Check' \
#                                        -c user.email='check@example.com' \
#                                        commit -q -m 'first commit'
#   (The -c flags supply an identity so the commit works even if you have no
#    global git config — a trick from the git week.)
# ===========================================================================
git_skill="no"
if command -v git >/dev/null 2>&1; then
  tmp_repo="$(mktemp -d "${TMPDIR:-/tmp}/toolkit-check-tmp.XXXXXX")"
  if (
    cd "${tmp_repo}" &&
    FILL_ME_IN &&
    echo "hello foundations" > note.txt &&
    git add note.txt &&
    FILL_ME_IN &&
    git log --oneline | grep -q 'first commit'
  ) >/dev/null 2>&1; then
    git_skill="yes"
  fi
  rm -rf "${tmp_repo}"
fi
skill_result "git init + commit works" "${git_skill}" "Days 29-30"

# ===========================================================================
# Exercise 3: a mini end-to-end that touches the command-line core.
#   Build a shell pipeline (Days 10-12) that filters the four words below to
#   those starting with 'a' and counts them. Replace FILL_ME_IN with:
#       printf 'apple\nbanana\napricot\ncherry\n' | grep '^a' | wc -l | tr -d ' '
#   The expected count is 2 (apple, apricot). This one line exercises text
#   tools, pipes, and counting — the command-line core of the section.
# ===========================================================================
pipe_skill="no"
count="$(FILL_ME_IN)"
[ "${count}" = "2" ] && pipe_skill="yes"
skill_result "shell pipeline works" "${pipe_skill}" "Days 10-12"

# Skill 3 (storage): create and query an in-memory SQLite table (done for you).
sql_skill="no"
if command -v sqlite3 >/dev/null 2>&1; then
  answer="$(sqlite3 ':memory:' 'CREATE TABLE t(x INTEGER); INSERT INTO t VALUES (42); SELECT x FROM t;' 2>/dev/null)"
  [ "${answer}" = "42" ] && sql_skill="yes"
fi
skill_result "sqlite query works" "${sql_skill}" "Day 39"

echo
echo "-- Readiness --"
echo "Tools present: ${tools_present} / ${tools_total}   Skills passed: ${skills_passed} / ${skills_total}"

# ===========================================================================
# Exercise 4: self-score. Print the readiness verdict. Replace the
# placeholder with a test that says you are ready only when the git and
# pipeline skills both passed AND python3 is installed:
#     [ "${git_skill}" = "yes" ] && [ "${pipe_skill}" = "yes" ] \
#        && command -v python3 >/dev/null 2>&1
# ===========================================================================
if FILL_ME_IN; then
  echo "You are ready for Course 2. Nice work finishing the foundations."
else
  echo "Almost there — revisit the day(s) shown next to any [--] line above, then re-run."
fi
echo "=== End of check ==="

# Computing Foundations self-assessment — Day 042 worksheet

This is the practice assignment. Fill it in honestly — it is a repair map,
not a grade. Rate your confidence in each of the six areas of Course 1 from
**1 (shaky)** to **5 (solid)**, and for each area note the exact day you would
revisit to improve. Keep this file: it is your personal map into Course 2.

## Confidence ratings

| # | Area | Days | Your rating (1-5) | Day you'd revisit | Why |
| - | ---- | ---- | ----------------- | ----------------- | --- |
| 1 | How computers work (the machine) | 1-7 |  |  |  |
| 2 | The command line | 8-14 |  |  |  |
| 3 | The internet | 15-21 |  |  |  |
| 4 | APIs | 22-28 |  |  |  |
| 5 | Git and GitHub | 29-35 |  |  |  |
| 6 | Systems foundations (storage, observability, automation) | 36-41 |  |  |  |

## Toolkit-check readiness line

Run `bash examples/toolkit_check.sh` and paste its readiness line here:

```
Tools present: __ / 6   Skills passed: __ / 3
Verdict: ______________________________________________
```

Note any tool that reported `[--]` and the day it maps to:

-

## My weakest area and my plan

Write one short paragraph (5-8 sentences) answering all three:

1. Which single area is your weakest, and why do you think so?
2. Which exact day will you revisit before or during Course 2?
3. What specifically do you expect to relearn there?

> _(write here)_

## One connection I now see

In one or two sentences, describe one way two of the six areas connect that
you did not appreciate before this review (for example, how an API failure is
really a networking question, or how git protects you from a storage mistake).

> _(write here)_

#!/usr/bin/env bash
# Tests for the Day 042 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the toolkit check runs, reports the core tools that this
# machine has (git, curl, python3), and that its end-to-end skill checks
# touch git, a SQLite query, and a shell pipeline. No network is used.
# If the learner has completed the starter (no FILL_ME_IN left), their
# version is held to the same standard.
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
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
}

has() { echo "$1" | grep -q "$2" && echo yes || echo no; }

run_check_script() {
  local script="$1" strict="$2" output
  echo "Testing ${script} ..."
  if ! output="$(bash "${script}" 2>&1)"; then
    check "script exits successfully" "no"
    echo "${output}" | sed 's/^/    /'
    return
  fi
  check "script exits successfully" "yes"

  # Structure: header, sections, footer.
  check "prints report header"        "$(has "${output}" '^=== Computing Foundations Toolkit Check ===$')"
  check "prints tool inventory block" "$(has "${output}" '^-- Tool inventory --$')"
  check "prints skill checks block"   "$(has "${output}" '^-- Skill checks --$')"
  check "prints readiness block"      "$(has "${output}" '^-- Readiness --$')"
  check "prints report footer"        "$(has "${output}" '^=== End of check ===$')"

  # Every tool line maps to a Course 1 day.
  check "tool lines map to a day" "$(has "${output}" 'maps to Day')"

  if [ "${strict}" = "strict" ]; then
    # Core tools known to be present on this machine must report [ok].
    for t in git curl python3; do
      check "reports ${t} present ([ok])" "$(echo "${output}" | grep -E "^\[ok\]   ${t}" >/dev/null && echo yes || echo no)"
    done
    # The end-to-end must exercise git + a query + a pipeline, all passing.
    check "git init + commit skill passes" "$(echo "${output}" | grep -E '^\[ok\]   git init \+ commit works' >/dev/null && echo yes || echo no)"
    check "sqlite query skill passes"      "$(echo "${output}" | grep -E '^\[ok\]   sqlite query works' >/dev/null && echo yes || echo no)"
    check "shell pipeline skill passes"    "$(echo "${output}" | grep -E '^\[ok\]   shell pipeline works' >/dev/null && echo yes || echo no)"
    # Readiness verdict for a fully-equipped machine.
    check "reports ready for Course 2" "$(has "${output}" 'You are ready for Course 2')"
  fi
}

# The completed reference must pass strictly on this machine.
run_check_script "${lab_dir}/examples/toolkit_check.sh" strict

# The starter ships with FILL_ME_IN placeholders in executable positions;
# once the learner replaces them all, hold their script to the same strict
# standard. (Match only the code forms, not the comment prose that names
# the placeholder, so a completed starter is graded strictly.)
if grep -qE '\$\(FILL_ME_IN\)|FILL_ME_IN &&|if FILL_ME_IN' "${lab_dir}/starter/toolkit_check.sh"; then
  echo "Note: starter/toolkit_check.sh still has unfilled exercises — testing structure only."
  run_check_script "${lab_dir}/starter/toolkit_check.sh" lenient
else
  run_check_script "${lab_dir}/starter/toolkit_check.sh" strict
fi

# Confirm the lab makes no network calls (offline by contract).
if grep -RIE 'curl [^|]*http|wget |ping ' "${lab_dir}/examples" "${lab_dir}/starter" >/dev/null 2>&1; then
  check "lab scripts make no network calls" "no"
else
  check "lab scripts make no network calls" "yes"
fi

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