Hands-on lab — Day 8: Meet the Terminal: Shells, Prompts, and Commands

#!/usr/bin/env bash
# Day 008 lab — completed reference implementation: a guided tour of your shell.
#
# Prints, in clearly labelled sections: which shell is running, your default
# shell, the shell process, your prompt string, and the output of a handful of
# everyday commands (pwd, echo, date, whoami, history, type). Every command is
# read-only — it inspects your session and changes nothing.
#
# Works in bash and zsh on macOS and Linux. Run it with:
#   bash examples/shell_tour.sh
set -u

echo "=== Shell Tour ==="
echo "Generated on: $(date '+%Y-%m-%d')"

echo
echo "--- Which shell am I running? ---"
# $0 is the name of the shell (or script) currently running.
echo "Current shell (echo \$0): $0"
# $SHELL is your DEFAULT login shell, which may differ from the one running now.
echo "Default shell (echo \$SHELL): ${SHELL:-unknown}"
# ps -p $$ shows the process of the current shell ($$ is its process id).
echo "Shell process (ps -p \$\$):"
ps -p $$ | sed 's/^/    /'

echo
echo "--- What does my prompt look like? ---"
# PS1 is the prompt-string template. In a non-interactive script it is often
# empty; run 'echo \"\$PS1\"' directly in your interactive shell to see it.
if [ -n "${PS1:-}" ]; then
  echo "Prompt string (echo \"\$PS1\"): ${PS1}"
else
  echo "Prompt string (echo \"\$PS1\"): (empty in this non-interactive run — try it in your interactive shell)"
fi

echo
echo "--- A handful of everyday commands ---"
echo "Working directory (pwd): $(pwd)"
echo "Echo demo (echo hello): $(echo hello)"
echo "Date (date): $(date)"
echo "User (whoami): $(whoami)"

echo
echo "--- Recent command history (history | tail) ---"
# 'history' is a shell built-in; in a non-interactive script the list may be
# empty. This is expected — the point is that your INTERACTIVE shell records it.
hist_output="$(history 2>/dev/null | tail || true)"
if [ -n "${hist_output}" ]; then
  echo "${hist_output}" | sed 's/^/    /'
else
  echo "    (no history in this non-interactive run — run 'history | tail' in your terminal)"
fi

echo
echo "--- What kind of thing is 'echo'? ---"
# 'type' tells you whether a name is a built-in, a program on disk, or an alias.
echo "type echo: $(type echo)"

echo
echo "=== End of tour ==="

lesson_id: D008
day: 8
kind: command-line-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-008-meet-the-terminal-shells-prompts-and
run_commands:
  - bash examples/shell_tour.sh
  - bash starter/shell_tour.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/shell_tour.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 → 35 checks, 0 failure(s).'

# Dependencies — Day 008 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: `ps`, `pwd`, `echo`, `date`, `whoami`, `sed`, `tail`,
  and the shell built-ins `history` and `type` — all part of the base system.

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

#!/usr/bin/env bash
# Day 008 lab — YOUR shell tour.
#
# This starter already prints the section headers and the demonstration lines
# (the shell process, your prompt string, a history sample, and 'type echo').
# Your job is the five numbered exercises below: replace each `unknown` with the
# single command shown in the comment, wrapped in $(...) so its output is
# captured. The finished reference version is in examples/shell_tour.sh — try it
# yourself first, then run this, then run the tests.
set -u

echo "=== Shell Tour ==="
echo "Generated on: $(date '+%Y-%m-%d')"

echo
echo "--- Which shell am I running? ---"

# Exercise 1: set current_shell using the command:  echo $0
#   ($0 is the name of the shell or script running right now.)
current_shell="unknown"

# Exercise 2: set default_shell using the command:  echo $SHELL
#   ($SHELL is your DEFAULT login shell — it may differ from the one running now.)
default_shell="unknown"

echo "Current shell (echo \$0): ${current_shell}"
echo "Default shell (echo \$SHELL): ${default_shell}"
echo "Shell process (ps -p \$\$):"
ps -p $$ | sed 's/^/    /'

echo
echo "--- What does my prompt look like? ---"
if [ -n "${PS1:-}" ]; then
  echo "Prompt string (echo \"\$PS1\"): ${PS1}"
else
  echo "Prompt string (echo \"\$PS1\"): (empty in this non-interactive run — try it in your interactive shell)"
fi

echo
echo "--- A handful of everyday commands ---"

# Exercise 3: set here using the command:  pwd
#   (pwd prints the working directory — the folder the shell is standing in.)
here="unknown"

# Exercise 4: set today using the command:  date
#   (date takes no options and no arguments; it prints the current date/time.)
today="unknown"

# Exercise 5: set me using the command:  whoami
#   (whoami prints your username — the identity your commands act as.)
me="unknown"

echo "Working directory (pwd): ${here}"
echo "Echo demo (echo hello): $(echo hello)"
echo "Date (date): ${today}"
echo "User (whoami): ${me}"

echo
echo "--- Recent command history (history | tail) ---"
hist_output="$(history 2>/dev/null | tail || true)"
if [ -n "${hist_output}" ]; then
  echo "${hist_output}" | sed 's/^/    /'
else
  echo "    (no history in this non-interactive run — run 'history | tail' in your terminal)"
fi

echo
echo "--- What kind of thing is 'echo'? ---"
echo "type echo: $(type echo)"

echo
echo "=== End of tour ==="

# My First Shell Session — Day 008 worksheet

Fill in every value from your own machine using the lab script or the individual
commands from the lesson's hands-on section. Keep this file — later lessons build
on your comfort at the prompt.

## My shell

| Field | Your value | Command you used |
| ----------------------------- | ---------- | ---------------- |
| Shell running right now       |            | `echo $0` (or `ps -p $$`) |
| My default login shell        |            | `echo $SHELL` |
| My raw prompt string (`$PS1`) |            | `echo "$PS1"` |

## Three commands I ran

For each command, write the exact command you typed, exactly what it printed
(one line is fine), and a one-sentence explanation of what it did — naming which
parts were the command, options, and arguments.

| # | Exact command | What it printed | What it did (and its command / options / arguments) |
| - | ------------- | --------------- | --------------------------------------------------- |
| 1 |               |                 |                                                     |
| 2 |               |                 |                                                     |
| 3 |               |                 |                                                     |

## How my command travelled through the read-eval-print loop

Write two or three sentences: name your shell, then trace one command you ran
from your keystrokes through the shell reading and parsing the line, finding and
running the program, printing the output, and the prompt returning.

## One thing that surprised me

One or two sentences.

#!/usr/bin/env bash
# Tests for the Day 008 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the completed reference tour prints every required section with
# real (non-"unknown") values, and — if the learner has finished the starter —
# checks their version the same way.
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_tour_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 '^=== Shell Tour ===$' && check "prints tour header" "yes" || check "prints tour header" "no"
  echo "${output}" | grep -q '^=== End of tour ===$' && check "prints tour footer" "yes" || check "prints tour footer" "no"
  # Required labelled sections (the tour must show each of these).
  for marker in \
    "Current shell (echo \$0):" \
    "Default shell (echo \$SHELL):" \
    "Shell process (ps -p \$\$):" \
    "Prompt string (echo \"\$PS1\"):" \
    "Working directory (pwd):" \
    "Echo demo (echo hello):" \
    "Date (date):" \
    "User (whoami):" \
    "Recent command history (history | tail)" \
    "type echo:"; do
    if echo "${output}" | grep -qF "${marker}"; then
      check "prints section '${marker}'" "yes"
    else
      check "prints section '${marker}'" "no"
    fi
  done
  # The echo demo must actually print the word it echoed.
  echo "${output}" | grep -qF "Echo demo (echo hello): hello" && check "echo hello prints 'hello'" "yes" || check "echo hello prints 'hello'" "no"
  # 'type echo' should identify echo as a shell builtin.
  echo "${output}" | grep -qi "echo is a shell builtin" && check "type echo reports a shell builtin" "yes" || check "type echo reports a shell builtin" "no"

  if [ "${strict}" = "strict" ]; then
    # In a finished tour, the five exercise fields must not read 'unknown'.
    for field in \
      "Current shell (echo \$0): unknown" \
      "Default shell (echo \$SHELL): unknown" \
      "Working directory (pwd): unknown" \
      "Date (date): unknown" \
      "User (whoami): unknown"; do
      if echo "${output}" | grep -qF "${field}"; then
        check "field is filled in, not 'unknown' (${field%%:*})" "no"
      else
        check "field is filled in, not 'unknown' (${field%%:*})" "yes"
      fi
    done
  fi
}

run_tour_checks "${lab_dir}/examples/shell_tour.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/shell_tour.sh"; then
  echo "Note: starter/shell_tour.sh still has unfilled exercises — testing structure only."
  run_tour_checks "${lab_dir}/starter/shell_tour.sh" lenient
else
  run_tour_checks "${lab_dir}/starter/shell_tour.sh" strict
fi

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