Hands-on lab — Day 6: Operating Systems: What They Do and Why

#!/usr/bin/env bash
# Day 006 lab — completed reference implementation.
# A guided tour of your operating system from the terminal: kernel, uptime,
# identity, shell, filesystems, top memory consumers, and where the kernel
# itself lives on disk. Supports macOS (Darwin) and Linux (including WSL);
# Windows users run this inside WSL.
#
# Note: we use `set -eu` here, deliberately without `pipefail` — pipelines
# like `ps aux | sort | head` end with head closing the pipe early, which
# is normal and expected, not an error.
set -eu

os="$(uname -s)"

echo "=== Meet Your Operating System ==="
echo "Generated on: $(date '+%Y-%m-%d')"

echo "--- Kernel ---"
echo "Kernel line (uname -a): $(uname -a)"
echo "Kernel name and release: $(uname -s) $(uname -r)"

echo "--- Uptime ---"
echo "Uptime:$(uptime)"

echo "--- Identity ---"
echo "Logged-in user: $(whoami)"
echo "Login shell: ${SHELL}"

echo "--- Mounted filesystems ---"
mount_count="$(df -h | tail -n +2 | wc -l | tr -d ' ')"
echo "Mounted filesystems reported by df: ${mount_count}"
echo "Root filesystem (mounted on /):"
df -h / | sed 's/^/  /'

echo "--- Top 5 processes by memory ---"
# Column 4 of `ps aux` is %MEM on both macOS and Linux; sort by it, descending.
echo "  USER          PID   %MEM  COMMAND"
ps aux | sort -k4 -nr | head -5 | awk '{
  cmd = $11; for (i = 12; i <= NF; i++) cmd = cmd " " $i;
  printf "  %-12s %6s  %4s%%  %.60s\n", $1, $2, $4, cmd
}'

echo "--- Where the kernel lives ---"
if [ "${os}" = "Darwin" ]; then
  kernel_path="/System/Library/Kernels/kernel"
  if [ -f "${kernel_path}" ]; then
    echo "macOS kernel (XNU) found at: ${kernel_path}"
    ls -lh "${kernel_path}" | awk '{print "  size: " $5 "  owner: " $3}'
  else
    echo "macOS kernel file not found at ${kernel_path} on this system."
    echo "(Some macOS versions relocate it; the kernel is still running — you are using it right now.)"
  fi
elif [ "${os}" = "Linux" ]; then
  kernel_image="$(ls /boot/vmlinuz* 2>/dev/null | head -n 1 || true)"
  if [ -n "${kernel_image}" ]; then
    echo "Linux kernel image found at: ${kernel_image}"
    ls -lh "${kernel_image}" | awk '{print "  size: " $5 "  owner: " $3}'
  else
    echo "No /boot/vmlinuz* image visible from this environment."
    echo "(Common and honest on WSL and in containers: the running kernel is supplied from outside this filesystem.)"
  fi
else
  echo "Unsupported OS for this script: ${os} (Windows users: run this inside WSL)" >&2
  exit 1
fi

echo "=== End of OS profile ==="

lesson_id: D006
day: 6
kind: os-exploration
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-006-operating-systems-what-they-do-and
run_commands:
  - bash examples/explore_os.sh
  - bash starter/explore_os.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/explore_os.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 → 29 checks, 0 failure(s)'

# Dependencies — Day 006 lab

**None beyond a POSIX shell.** This lab intentionally has zero installable
dependencies:

- `bash` ≥ 3.2 (preinstalled on macOS and every mainstream Linux distribution)
- Standard OS utilities only: `uname`, `date`, `uptime`, `whoami`, `df`,
  `ps`, `sort`, `head`, `awk`, `sed`, `ls`, `wc` — all part of the base
  system on macOS and Linux (and inside WSL).

Windows users need WSL (`wsl --install`) — a one-time setup that the rest
of this course relies on from Week 2 onward, so today is the right day to
do it.

There is deliberately no `requirements.txt`/`package.json` here; like Day 1,
this lab must run on a factory-fresh machine. Later labs declare their
Python or Node dependencies in this directory.

#!/usr/bin/env bash
# Day 006 lab — meet your operating system from the command line.
#
# This starter script already prints the report skeleton and handles the
# OS-specific "where is the kernel" section for you. Your job is to complete
# the five numbered exercises below, replacing each `unknown` assignment with
# the command named in the comment, in `$(...)` form. The completed reference
# version is in examples/explore_os.sh — try it yourself first.
#
# Note: we use `set -eu` here, deliberately without `pipefail` — pipelines
# like `ps aux | sort | head` end with head closing the pipe early, which
# is normal and expected, not an error.
set -eu

os="$(uname -s)"
if [ "${os}" != "Darwin" ] && [ "${os}" != "Linux" ]; then
  echo "Unsupported OS for this script: ${os} (Windows users: run this inside WSL)" >&2
  exit 1
fi

echo "=== Meet Your Operating System ==="
echo "Generated on: $(date '+%Y-%m-%d')"

echo "--- Kernel ---"
# Exercise 1: set kernel_line using: uname -a
#   (uname asks the kernel to describe itself: name, release, architecture.)
kernel_line="unknown"
echo "Kernel line (uname -a): ${kernel_line}"

echo "--- Uptime ---"
# Exercise 2: set up_line using: uptime
#   (how long the kernel has been running since boot, plus load averages.)
up_line="unknown"
echo "Uptime: ${up_line}"

echo "--- Identity ---"
# Exercise 3a: set current_user using: whoami
current_user="unknown"
# Exercise 3b: set login_shell from the SHELL environment variable: echo "$SHELL"
#   (hint: you do not even need a command — "${SHELL}" is already the value.)
login_shell="unknown"
echo "Logged-in user: ${current_user}"
echo "Login shell: ${login_shell}"

echo "--- Mounted filesystems ---"
# Exercise 4: set root_fs to the df -h report for the root filesystem: df -h /
#   (both header and data row; keep the quotes so the newline survives.)
root_fs="unknown"
echo "Root filesystem (mounted on /):"
echo "${root_fs}" | sed 's/^/  /'

echo "--- Top 5 processes by memory ---"
# Exercise 5: set top_procs using: ps aux | sort -k4 -nr | head -5
#   (ps aux lists every process; column 4 is %MEM; sort -k4 -nr orders by it,
#   biggest first; head -5 keeps the top five.)
top_procs="unknown"
echo "${top_procs}" | awk '{
  cmd = $11; for (i = 12; i <= NF; i++) cmd = cmd " " $i;
  printf "  %-12s %6s  %4s%%  %.60s\n", $1, $2, $4, cmd
}'

echo "--- Where the kernel lives ---"
if [ "${os}" = "Darwin" ]; then
  kernel_path="/System/Library/Kernels/kernel"
  if [ -f "${kernel_path}" ]; then
    echo "macOS kernel (XNU) found at: ${kernel_path}"
    ls -lh "${kernel_path}" | awk '{print "  size: " $5 "  owner: " $3}'
  else
    echo "macOS kernel file not found at ${kernel_path} on this system."
    echo "(Some macOS versions relocate it; the kernel is still running — you are using it right now.)"
  fi
else
  kernel_image="$(ls /boot/vmlinuz* 2>/dev/null | head -n 1 || true)"
  if [ -n "${kernel_image}" ]; then
    echo "Linux kernel image found at: ${kernel_image}"
    ls -lh "${kernel_image}" | awk '{print "  size: " $5 "  owner: " $3}'
  else
    echo "No /boot/vmlinuz* image visible from this environment."
    echo "(Common and honest on WSL and in containers: the running kernel is supplied from outside this filesystem.)"
  fi
fi

echo "=== End of OS profile ==="

# My OS Profile — Day 006 worksheet

This worksheet extends the machine profile you built on Day 1 with the
operating-system layer. Fill in every value from your own machine using the
lab script or the individual commands from the lesson's hands-on section.
Keep it next to your Day 1 worksheet — the Week 1 project uses both.

| Field                              | Your value | Command you used |
| ---------------------------------- | ---------- | ---------------- |
| Date measured                      |            |                  |
| Kernel name                        |            |                  |
| Kernel release/version             |            |                  |
| OS / distribution name and version |            |                  |
| Uptime at time of measurement      |            |                  |
| Logged-in user                     |            |                  |
| Login shell                        |            |                  |
| Filesystems mounted (count)        |            |                  |
| Root filesystem free space         |            |                  |
| Total process count                |            |                  |
| Top memory-consuming process       |            |                  |

## One process I looked up

Pick one process from `ps aux` whose name you did not recognize. Search the
web for its name plus your OS, then write two or three sentences: what it
is, and which of the OS's five jobs (processes, memory, filesystems,
drivers, security) it serves.

## My machine's two worlds

Write one paragraph: name three programs from your process list that you
started yourself and three you never started, and explain — in kernel/user-
space terms — why all six still had to go through the same system-call
boundary for everything they have done since boot.

## One thing that surprised me

One or two sentences.

#!/usr/bin/env bash
# Tests for the Day 006 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the completed reference script exits cleanly and prints every
# required section of the OS profile with real (non-"unknown") values, and —
# once the learner has finished the starter script — checks their version the
# same way. Exits 0 on success, 1 on any failure.
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
}

run_profile_checks() {
  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"
  echo "${output}" | grep -q '^=== Meet Your Operating System ===$' && check "prints profile header" "yes" || check "prints profile header" "no"
  echo "${output}" | grep -q '^=== End of OS profile ===$' && check "prints profile footer" "yes" || check "prints profile footer" "no"
  for section in "--- Kernel ---" "--- Uptime ---" "--- Identity ---" "--- Mounted filesystems ---" "--- Top 5 processes by memory ---" "--- Where the kernel lives ---"; do
    echo "${output}" | grep -q "^${section}$" && check "prints section '${section}'" "yes" || check "prints section '${section}'" "no"
  done
  for field in "Kernel line (uname -a):" "Logged-in user:" "Login shell:" "Root filesystem (mounted on /):"; do
    echo "${output}" | grep -q "^${field}" && check "prints '${field}'" "yes" || check "prints '${field}'" "no"
  done
  if [ "${strict}" = "strict" ]; then
    if echo "${output}" | grep -q "unknown"; then
      check "no field is left 'unknown'" "no"
    else
      check "no field is left 'unknown'" "yes"
    fi
    # The kernel line must actually name a kernel this course supports.
    if echo "${output}" | grep -E '^Kernel line \(uname -a\): (Darwin|Linux)' >/dev/null; then
      check "kernel line names Darwin or Linux" "yes"
    else
      check "kernel line names Darwin or Linux" "no"
    fi
    # The top-processes section must contain at least one PID-looking row.
    procs_section="$(echo "${output}" | sed -n '/^--- Top 5 processes by memory ---$/,/^--- Where the kernel lives ---$/p')"
    if echo "${procs_section}" | grep -E '[0-9]+ ' >/dev/null; then
      check "top-processes section lists real processes" "yes"
    else
      check "top-processes section lists real processes" "no"
    fi
  fi
}

run_profile_checks "${lab_dir}/examples/explore_os.sh" strict

# The starter ships with 'unknown' values on purpose; once the learner has
# replaced them all, hold their script to the same strict standard.
if grep -q '"unknown"' "${lab_dir}/starter/explore_os.sh"; then
  echo "Note: starter/explore_os.sh still has unfilled exercises — testing structure only."
  run_profile_checks "${lab_dir}/starter/explore_os.sh" lenient
else
  run_profile_checks "${lab_dir}/starter/explore_os.sh" strict
fi

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