Hands-on lab — Day 5: Text, Images, and Sound as Data

#!/usr/bin/env bash
# Day 005 lab — completed reference walkthrough: X-ray the three sample
# files with `file`, `wc`, and `xxd` and point at what the bytes mean.
#
# Run from anywhere:  bash examples/inspect_bytes.sh
set -euo pipefail

samples="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/samples"
cd "${samples}"   # so every tool prints short, machine-neutral file names

section() {
  echo
  echo "=== $1 ==="
}

section "1. hello.txt — plain ASCII, one byte per character"
file hello.txt
echo "size in bytes:      $(wc -c < hello.txt | tr -d ' ')"
echo "size in characters: $(wc -m < hello.txt | tr -d ' ')"
xxd hello.txt
echo "Note: 13 visible characters + 1 newline (0a) = 14 bytes."
echo "Note: 'H' = 48 hex = 72 decimal, exactly its ASCII code."

section "2. unicode.txt — UTF-8 with 1-, 2-, 3-, and 4-byte characters"
file unicode.txt
echo "size in bytes:      $(wc -c < unicode.txt | tr -d ' ')"
echo "size in characters: $(wc -m < unicode.txt | tr -d ' ')"
xxd unicode.txt
echo "Note: bytes and characters differ because some characters need"
echo "several bytes. Look for these multi-byte UTF-8 sequences above:"
echo "  c3 a9        = e-acute      (U+00E9, 2 bytes)"
echo "  e2 82 ac     = euro sign    (U+20AC, 3 bytes)"
echo "  f0 9f 8e 89  = party emoji  (U+1F389, 4 bytes)"
echo "xxd prints a dot in the right-hand column for every byte that is"
echo "not printable ASCII — that is why the accents look like dots."

section "3. tiny.png — a real binary file with magic bytes"
file tiny.png
echo "size in bytes:      $(wc -c < tiny.png | tr -d ' ')"
echo "first 8 bytes (the PNG signature):"
xxd -l 8 tiny.png
echo "89 50 4e 47 0d 0a 1a 0a — bytes 2-4 spell 'PNG' in ASCII."
echo "full dump (note the readable chunk names IHDR, tEXt, IDAT, IEND):"
xxd tiny.png

section "4. Extensions lie; magic bytes do not"
workdir="$(mktemp -d)"
cp "${samples}/hello.txt" "${workdir}/hello.png"
cp "${samples}/tiny.png" "${workdir}/tiny.txt"
echo "Renamed hello.txt -> hello.png. What does 'file' say?"
(cd "${workdir}" && file hello.png)
echo "Renamed tiny.png -> tiny.txt. What does 'file' say?"
(cd "${workdir}" && file tiny.txt)
echo "'file' reads the CONTENT (magic bytes), not the name: the fake"
echo ".png is still ASCII text, and the fake .txt is still PNG image data."
rm -rf "${workdir}"

echo
echo "=== End of byte walkthrough ==="

#!/usr/bin/env bash
# Day 005 lab — (re)build the three sample files in examples/samples/.
#
# The samples ship with the repository, so you normally never need to run
# this. It exists so you can see that every byte in the samples is
# deliberate: the text files are written byte by byte with printf escape
# sequences, and the PNG is decoded from base64 text back into its exact
# 145 binary bytes.
set -euo pipefail

samples_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/samples"
mkdir -p "${samples_dir}"

# 1. hello.txt — pure ASCII: every character is exactly one byte.
printf 'Hello, world!\n' > "${samples_dir}/hello.txt"

# 2. unicode.txt — UTF-8 with 1-, 2-, 3-, and 4-byte characters:
#      \xc3\xa9          = é (U+00E9, 2 bytes)
#      \xe2\x82\xac      = € (U+20AC, 3 bytes)
#      \xf0\x9f\x8e\x89  = party-popper emoji (U+1F389, 4 bytes)
printf 'caf\xc3\xa9 costs 3 \xe2\x82\xac\nr\xc3\xa9sum\xc3\xa9\n\xf0\x9f\x8e\x89\n' \
  > "${samples_dir}/unicode.txt"

# 3. tiny.png — a real, valid 145-byte PNG: a 2x2 image whose pixels are
#    red, green, blue, and white, plus a tEXt chunk holding a comment.
#    The binary bytes are stored here as base64 text and decoded back.
png_b64='iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91JpzAAAAOnRFWHRDb21tZW50AERheSA1IHNhbXBsZTogMngyIHBpeGVscyAtIHJlZCwgZ3JlZW4sIGJsdWUsIHdoaXRllGR9ewAAABJJREFUeNpj+M/AwADCDP+BAAAf7gX78au6dwAAAABJRU5ErkJggg=='
if printf %s "${png_b64}" | base64 -d > "${samples_dir}/tiny.png" 2>/dev/null; then
  :  # GNU coreutils and modern macOS accept -d
else
  printf %s "${png_b64}" | base64 -D > "${samples_dir}/tiny.png"  # older macOS uses -D
fi

echo "Samples written to ${samples_dir}:"
file "${samples_dir}/hello.txt" "${samples_dir}/unicode.txt" "${samples_dir}/tiny.png"

Hello, world!

�PNG


IHDR�Ԛs:tEXtCommentDay 5 sample: 2x2 pixels - red, green, blue, white�d}{IDATx�c����������wIEND�B`�

café costs 3 €
résumé
🎉

lesson_id: D005
day: 5
kind: encoding-inspection
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-005-text-images-and-sound-as-data
run_commands:
  - bash examples/inspect_bytes.sh
  - bash starter/inspect_bytes.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/inspect_bytes.sh starter/byte-detective-worksheet.md  # 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 → 18 checks, 0 failure(s).'

# Dependencies — Day 005 lab

**None beyond a POSIX shell and standard utilities.** Everything this lab
uses ships with macOS and mainstream Linux distributions:

- `bash` ≥ 3.2 (preinstalled on macOS and Linux)
- `xxd` — the hex-dump tool (ships with vim; preinstalled on macOS, and
  present on nearly every Linux distribution via the `vim`/`vim-common`
  or `xxd` package)
- `file` — identifies file types by magic bytes (preinstalled everywhere)
- `wc`, `cp`, `mktemp`, `printf` — POSIX basics
- `base64` — only needed if you re-run `examples/make_samples.sh`
- `hexdump` — optional alternative to `xxd` shown in the README

There is deliberately no `requirements.txt`/`package.json`: the sample
files are committed to the repository, so nothing needs to be downloaded
or installed. If `xxd` is missing on a minimal Linux container, install it
with your package manager (e.g. `sudo apt install xxd` on Debian/Ubuntu).

# Byte-detective worksheet — Day 005

Answer every question by **running a command and reading real bytes**, not
from memory. The commands you need are named in `starter/inspect_bytes.sh`
and demonstrated in `examples/inspect_bytes.sh`. Work from the lab
directory. Write your answers directly into this file.

## Part 1 — hello.txt (plain ASCII)

Run `xxd examples/samples/hello.txt` and `wc -c examples/samples/hello.txt`.

1. How many bytes is `hello.txt`, and how many characters do you *see* in
   the text? Explain why the two numbers relate the way they do (remember
   the invisible newline).

   Answer:

2. What is the hex value of the first byte, and which character is it?
   (Check it against the ASCII column on the right of the xxd output.)

   Answer:

3. What is the very last byte of the file in hex, and what character is
   it? Why does xxd print a dot for it in the right-hand column?

   Answer:

## Part 2 — unicode.txt (UTF-8)

Run `xxd examples/samples/unicode.txt`, then `wc -c` and `wc -m` on it.

4. Which two bytes (hex) encode the character é? How many times does that
   two-byte sequence appear in the file, and which words do they belong to?

   Answer:

5. `wc -c` and `wc -m` report different numbers for this file. Write both
   numbers and account for the difference exactly: which characters take
   2, 3, and 4 bytes?

   Answer:

6. Which four bytes (hex) encode the party-popper emoji? What do the first
   few bits of the leading byte tell a UTF-8 decoder?

   Answer:

## Part 3 — tiny.png (binary with magic bytes)

Run `xxd -l 8 examples/samples/tiny.png`, then the full
`xxd examples/samples/tiny.png`, and `file examples/samples/tiny.png`.

7. What are the first 4 bytes of the PNG in hex? Which three ASCII letters
   hide inside bytes 2–4?

   Answer:

8. `file` reports the image is "2 x 2". Find the readable chunk names in
   the full dump (IHDR, tEXt, IDAT, IEND). What human-readable sentence is
   stored inside the tEXt chunk?

   Answer:

## Part 4 — extensions versus content

Copy the samples under wrong names (use a scratch directory, e.g.
`cp examples/samples/hello.txt /tmp/hello.png`), then run `file` on the
copies.

9. When you rename `hello.txt` to `hello.png`, what does `file` say about
   it — and what does that prove about where a file's "type" really lives?

   Answer:

10. When you rename `tiny.png` to `tiny.txt` and double-click it or `cat`
    it, things look broken — yet `file` still knows what it is. Explain
    the difference between what your operating system's file manager uses
    (the extension) and what `file` uses (the magic bytes).

    Answer:

#!/usr/bin/env bash
# Day 005 lab — YOUR working file: X-ray the sample files with xxd and file.
#
# The skeleton below runs as-is, but each of the four exercises prints a
# placeholder line. Your job: replace each placeholder `echo` line with the
# exact command named in the comment above it, then re-run the script.
# The finished version is in examples/inspect_bytes.sh — try it yourself
# before peeking.
#
# Run from anywhere:  bash starter/inspect_bytes.sh
set -euo pipefail

samples="$(cd "$(dirname "${BASH_SOURCE[0]}")/../examples" && pwd)/samples"

echo "=== Byte detective: my own run ==="

echo
echo "--- Exercise 1: dump plain ASCII text ---"
# Replace the placeholder line below with exactly:
#   xxd "${samples}/hello.txt"
# Then answer on the worksheet: which hex byte is the capital H? Which
# byte is the invisible newline at the end?
echo "exercise 1 not completed yet"

echo
echo "--- Exercise 2: find multi-byte UTF-8 characters ---"
# Replace the placeholder line below with exactly:
#   xxd "${samples}/unicode.txt"
# Then find the two bytes of e-acute (c3 a9), the three bytes of the euro
# sign (e2 82 ac), and the four bytes of the emoji (f0 9f 8e 89).
echo "exercise 2 not completed yet"

echo
echo "--- Exercise 3: read the PNG magic bytes ---"
# Replace the placeholder line below with exactly:
#   xxd -l 8 "${samples}/tiny.png"
# The -l 8 flag limits the dump to the first 8 bytes — the PNG signature.
# On the worksheet, write down the first four bytes in hex.
echo "exercise 3 not completed yet"

echo
echo "--- Exercise 4: prove that extensions lie ---"
# Replace the placeholder line below with exactly:
#   cp "${samples}/hello.txt" "${workdir}/hello.png" && file "${workdir}/hello.png"
# The copy has a .png name but text content. Which one does `file` trust?
workdir="$(mktemp -d)"
echo "exercise 4 not completed yet"
rm -rf "${workdir}"

echo
echo "=== End of my run ==="

#!/usr/bin/env bash
# Tests for the Day 005 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies that the committed sample files are what they claim to be
# (checked by content, not by name), that the reference walkthrough runs
# and shows the expected byte sequences, and that the learner's starter
# script at least runs (held to the strict standard once every
# placeholder has been replaced).
set -u

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

contains() {  # contains <haystack> <needle>
  case "$1" in *"$2"*) return 0 ;; *) return 1 ;; esac
}

echo "Checking sample files exist ..."
for f in hello.txt unicode.txt tiny.png; do
  [ -s "${samples}/${f}" ] && check "samples/${f} exists and is non-empty" "yes" \
                           || check "samples/${f} exists and is non-empty" "no"
done

echo "Checking 'file' identifies each sample by content ..."
contains "$(file "${samples}/hello.txt")" "ASCII text" \
  && check "hello.txt is ASCII text" "yes" || check "hello.txt is ASCII text" "no"
contains "$(file "${samples}/unicode.txt")" "UTF-8" \
  && check "unicode.txt is UTF-8 text" "yes" || check "unicode.txt is UTF-8 text" "no"
contains "$(file "${samples}/tiny.png")" "PNG image data" \
  && check "tiny.png is PNG image data" "yes" || check "tiny.png is PNG image data" "no"

echo "Checking the exact bytes with xxd ..."
png_sig="$(xxd -p -l 8 "${samples}/tiny.png" | tr -d '\n')"
[ "${png_sig}" = "89504e470d0a1a0a" ] \
  && check "tiny.png starts with the PNG magic bytes 89 50 4e 47 0d 0a 1a 0a" "yes" \
  || check "tiny.png starts with the PNG magic bytes 89 50 4e 47 0d 0a 1a 0a" "no"
uni_hex="$(xxd -p "${samples}/unicode.txt" | tr -d '\n')"
contains "${uni_hex}" "c3a9" \
  && check "unicode.txt contains the 2-byte sequence c3 a9 (e-acute)" "yes" \
  || check "unicode.txt contains the 2-byte sequence c3 a9 (e-acute)" "no"
contains "${uni_hex}" "e282ac" \
  && check "unicode.txt contains the 3-byte sequence e2 82 ac (euro sign)" "yes" \
  || check "unicode.txt contains the 3-byte sequence e2 82 ac (euro sign)" "no"
contains "${uni_hex}" "f09f8e89" \
  && check "unicode.txt contains the 4-byte sequence f0 9f 8e 89 (emoji)" "yes" \
  || check "unicode.txt contains the 4-byte sequence f0 9f 8e 89 (emoji)" "no"
hello_hex="$(xxd -p "${samples}/hello.txt" | tr -d '\n')"
[ "${hello_hex}" = "48656c6c6f2c20776f726c64210a" ] \
  && check "hello.txt is exactly the 14 ASCII bytes of 'Hello, world!' + newline" "yes" \
  || check "hello.txt is exactly the 14 ASCII bytes of 'Hello, world!' + newline" "no"

echo "Checking content beats extension ..."
tmp="$(mktemp -d)"
cp "${samples}/tiny.png" "${tmp}/disguised.txt"
contains "$(file "${tmp}/disguised.txt")" "PNG image data" \
  && check "'file' still sees PNG content behind a .txt name" "yes" \
  || check "'file' still sees PNG content behind a .txt name" "no"
rm -rf "${tmp}"

echo "Running the reference walkthrough (examples/inspect_bytes.sh) ..."
if output="$(bash "${lab_dir}/examples/inspect_bytes.sh" 2>&1)"; then
  check "reference walkthrough exits successfully" "yes"
  contains "${output}" "8950 4e47" \
    && check "walkthrough output shows the PNG magic bytes" "yes" \
    || check "walkthrough output shows the PNG magic bytes" "no"
  contains "${output}" "c3a9" \
    && check "walkthrough output shows the e-acute bytes" "yes" \
    || check "walkthrough output shows the e-acute bytes" "no"
  contains "${output}" "PNG image data" \
    && check "walkthrough shows 'file' identifying the PNG" "yes" \
    || check "walkthrough shows 'file' identifying the PNG" "no"
else
  check "reference walkthrough exits successfully" "no"
  echo "${output}" | sed 's/^/    /'
fi

echo "Running your starter script (starter/inspect_bytes.sh) ..."
if s_output="$(bash "${lab_dir}/starter/inspect_bytes.sh" 2>&1)"; then
  check "starter script exits successfully" "yes"
else
  check "starter script exits successfully" "no"
  echo "${s_output}" | sed 's/^/    /'
  s_output=""
fi
if contains "$(cat "${lab_dir}/starter/inspect_bytes.sh")" "not completed yet"; then
  echo "Note: starter still has unfinished exercises — structure checked only."
  contains "${s_output}" "=== Byte detective: my own run ===" \
    && check "starter prints its header" "yes" || check "starter prints its header" "no"
else
  contains "${s_output}" "8950 4e47" \
    && check "your run shows the PNG magic bytes (exercise 3)" "yes" \
    || check "your run shows the PNG magic bytes (exercise 3)" "no"
  contains "${s_output}" "c3a9" \
    && check "your run shows the e-acute bytes (exercise 2)" "yes" \
    || check "your run shows the e-acute bytes (exercise 2)" "no"
  contains "${s_output}" "ASCII text" \
    && check "your run shows 'file' trusting content over the .png name (exercise 4)" "yes" \
    || check "your run shows 'file' trusting content over the .png name (exercise 4)" "no"
fi

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