UC Carpentries Workshop Series · Fall 2026

The Unix Shell

Wednesday, September 9 · 9:00 am – 12:00 pm PT · Terminal (macOS) / Git Bash (Windows)

Notes: tim-dennis.com/2026-09-08-uc-carpentries/shell-notes/

Etherpad: pad.carpentries.org/2026-fall-uc-shell-novice

Data: shell-lesson-data.zip on your Desktop, unzipped to a shell-lesson-data folder

Software Carpentry, The Unix Shell (CC BY 4.0) · today: Episodes 1–6

This deck is 8 slides on purpose. It carries the framing and the four diagrams (filesystem tree, command shape, the pipe, the loop). Everything else is live at the prompt - the command-by-command spine is on the notes page: tim-dennis.com/2026-09-08-uc-carpentries/shell-notes/#live-coding-spine. Open that on a second screen.

Holding slide - learners arriving (9:00)

Greet people by name
Ask them to: (1) add their name to the Etherpad; (2) open their shell - Terminal on Mac, Git Bash on Windows; (3) confirm there is a shell-lesson-data folder on their Desktop

Two instructors, two parts (Tim + James Frew; helpers Geoffrey Boushey + Jose Nino Muriel):

Part 1 - Episodes 1-3, ~9:00-10:38: get everyone to the prompt, why the shell, navigating, creating / moving / deleting files, wildcards. Contains the first break. Diagrams: slides 6 and 7.
Part 2 - Episodes 4-6, ~10:38-12:00: pipes & filters, loops, shell scripts. Contains the second break. Diagrams: slides 8 and 9.
Handoff after the wildcards exercise. Whoever is not driving watches the room, reads chat + pad aloud, keeps time.
Pace is brisk. Official time for Ep 1-6 is ~225 min against ~160 min of teaching time. Episode 7 (Finding Things / grep / find) is the standard cut. Trim exercises before demos; loops and scripts are the compressible end. Cut points are marked in the notes spine.
Helpers watch chat + pad, DM anyone who posts a red x.

Zoom model, all session: instructor screen-shares one window - the terminal, ~150%, large font, short prompt (PS1='$ '), colour off; learners work in their own terminal; done / stuck = a Zoom reaction or a chat line; questions go in the pad.

Before we start everyone

Open a shell

macOS — Terminal

Press ⌘ + Space, type terminal, hit Enter
Or: Finder → Applications → Utilities → Terminal

Windows — Git Bash

Click Start (or tap the ⊞ key), type git bash, hit Enter
Or: right-click inside a folder → Git Bash Here
No Git Bash? Install it — link below

Add your OS to your Zoom name - "Sam (Mac)" / "Sam (Windows)" - so helpers know which instructions apply

Setup / install: swcarpentry.github.io/shell-novice/#setup · Linux: your normal terminal, nothing to install

a shell / terminal / console / command line - all the same thing: a window where you type commands and read text back

8:55-9:00 (holding) into 9:00 · open a shell · the #1 stumbling block - walk the room through it

SAY

Before we do anything, everyone needs a shell window open. Mac and Windows are different - I'll show both.
Mac: Spotlight (Cmd-Space), type "terminal", Enter. It lives in Applications → Utilities if search fails.
Windows: we use Git Bash (installed with Git for Windows). Start menu, type "git bash", Enter. Not the built-in Command Prompt or PowerShell - those aren't bash.
You'll get a window with a $ or a > prompt. That's success. We fix the look of it in a moment.

THEN - anyone without a working shell: helper takes them to a breakout with the setup link (swcarpentry.github.io/shell-novice/#setup). Chromebook / locked-down machine / nothing works: pair them with a neighbour for today, sort setup after. Don't hold the whole room. → slide 3

Before we start everyone

Get to the prompt

Everyone, right now

Shell open (previous slide). You'll see a $ - the prompt. Don't type it; type what comes after.
Data on your Desktop? shell-lesson-data.zip from swcarpentry.github.io/shell-novice/#setup, unzipped to a shell-lesson-data folder.
In your shell, type these two lines:

$ cd ~/Desktop/shell-lesson-data $ ls

You should see exercise-data/ and north-pacific-gyre/.

$ whoami you $ pwd /Users/you $ cd ~/Desktop/shell-lesson-data $ ls exercise-data/ north-pacific-gyre/

Post in chat: a green check when you see those two folders, a red x if not.

Helpers: DM the setup + data links to anyone with a red x; take them into a breakout if needed.

the shell runs a read-evaluate-print loop (REPL): you type, it reads, it runs, it prints, it waits; the $ is the prompt - "ready for input"

9:00-9:10 · get everyone to the prompt · the riskiest ten minutes - do not rush it

SAY

The $ is the prompt. Yours might have your username and machine name in front - fine, ignore it, focus on the $. We never type the $. Press Enter to run a command.
The loop: you type a command, the shell reads it, runs it, prints the result, waits. Read-evaluate-print.
Blank line back = it worked. command not found = typo or not installed. No such file or directory = the path is wrong or you're not where you think.

TYPE (slowly, name each one)

whoami
pwd
cd ~/Desktop/shell-lesson-data
ls

THEN - watch the chat. Do not move on until it is mostly green checks. Common failures: no shell-lesson-data folder (helper DMs the data link), unzipped to Downloads not Desktop (cd ~/Downloads/shell-lesson-data for now), Windows path (cd ~/Desktop/shell-lesson-data still works in Git Bash). → slide 4

Why the shell

Why the command line?

So much runs on it - installing software, remote servers, containers, and HPC job scripts all assume shell basics
Your commands are the record - a pipeline you can re-run is a methods section a GUI never writes down
It's the glue between tools - an R script, a Python model, and someone's C binary all meet in the shell
AI coding agents work by typing shell commands - reviewing what an agent changed needs the same skill

Where it shows up

On an HPC cluster your job is a Bash script handed to a scheduler. Reproducibility tools - Snakemake, Nextflow, Docker, CI - are shell orchestrators. AI agents like Claude Code and Cursor run in a terminal you supervise.

On Zoom: in the chat - where have you hit a wall that a terminal would have gotten you past?

the shell is the layer HPC schedulers and AI agents both sit on top of

Concept 1 discuss

Why type when you can click?

A GUI is great for one file. It scales badly to hundreds.
A CLI lets you write instructions once and run them on 1, 100, or 10,000 files
The commands you type are a record - save them, re-run them, share them
It's the on-ramp to Python, R, Git, and working on a server

Nelle's problem

Nelle is back from a 6-month survey with 1520 sample files. Each has to go through one analysis program. By hand: open, run, save - 1520 times, ~12 hours of clicking.

Today's six episodes are the steps that let her computer do that while she writes her paper.

On Zoom: in the chat - one repetitive file task that has eaten an afternoon of your time.

Unix's design rule: small pieces, loosely joined - many tiny tools that each do one job well and combine

Navigating · Episode 2

The filesystem is a tree

You are always somewhere - pwd tells you where
A path is the trail of names: /Users/you/Desktop
/ root · ~ home · . here · .. one level up
Absolute starts at / and means the same anywhere; relative is from where you stand

Tab completes names · ↑ recalls the last command

your home directory is where a new shell starts; cd with no argument always returns there

9:16-9:51 · navigating · LIVE at the prompt · SWC Episode 2

This slide is the picture only. The commands are live - follow the notes spine, "Navigating (Episode 2)": pwd, ls and -F / -l / -lh / -a, man ls (say "press q to quit" loudly) / ls --help, the unknown-option error, cd in / .. up / home / cd -, the deliberate sibling-directory error, absolute vs relative paths, Tab completion.

Exercise (~7 min, ~9:44): ls nor + Tab; which cd options reach home; the alkanes round-trip (one relative path in, one absolute path back). Answers in the notes spine.

THEN - reconvene, everyone back in shell-lesson-data, then BREAK, 8 min (back ~10:00). Coming back: name the parts of a command once (command / option / argument), re-anchor with pwd, then into creating files. → slide 7

Navigating · recap

The shape of a command

A command may take no options and no arguments (ls), or several of each
Capitalisation matters: -s and -S are different options
Miss the space - ls-F - and the shell looks for a command called ls-F
Don't memorise options - look them up: man ls (q quits) or ls --help

options and arguments together are parameters; options that take no value are also called flags or switches

Pipes & filters · Episode 4

Redirect, and the pipe

> - send output to a file instead of the screen (overwrites, no prompt)
>> - append to a file instead of overwriting
| - send output straight into the next command, no temp file
Build a pipeline one stage at a time; read it left to right

$ wc -l *.pdb $ wc -l *.pdb | sort -n $ wc -l *.pdb | sort -n | head -n 1

tools that read standard input and write standard output snap together - Unix calls this pipes and filters

Automation · Episodes 5–6

Loops: do it to the whole list

Three files - or three hundred. You don't type the command once per file.

for thing in list_of_things do operation_using $thing done

for repeats the block once per item in the list
each pass, the loop variable holds the current item; $thing reads its value
the prompt changes to > while the shell waits for done - not broken, just waiting
echo in front of the commands = a dry run: see what it would do before it does it

this is a for loop; a variable walking a list is the same shape in every programming language you'll meet - and a script is just these commands saved in a file, run with bash

11:16-11:57 · loops, then scripts · LIVE at the prompt · SWC Episodes 5-6

This slide is the form only. Commands are live - notes spine, "Loops (Episode 5)" and "Shell scripts (Episode 6)":

The creatures loop: for filename in basilisk.dat minotaur.dat unicorn.dat / echo $filename + head -n 2 $filename | tail -n 1. Narrate one full iteration.
Dry run + backup loop: for f in *.dat; do echo cp $f original-$f; done, then without echo.
Loop-trace exercise (ls *.pdb vs ls $f inside a loop) - cut this if behind.
Scripts: nano sorted.sh = # comment + wc -l *.pdb | sort -n, run with bash sorted.sh. Then change *.pdb to "$@" so the caller picks the files. Skip the $1/$2 aside if short on time.

THEN → slide 10, recap + feedback.

Recap

pwd / ls / cd - know where you are, always
options begin with -; man and --help list them
paths: / root, . here, .. up, ~ home
nano, mkdir, mv, cp, rm - and rm has no undo
* and ? match many files; the shell expands them first

wc counts; sort/head/tail/cut/uniq transform
> writes a file, >> appends, | feeds the next command
for … do … done repeats a command over a list
echo in front of a loop = a safe dry run
save commands in a script; "$@" lets the caller pick the files

swcarpentry.github.io/shell-novice · Episodes 1–6 · data: shell-lesson-data (CC BY 4.0) · feedback link in the Etherpad