Free through lesson 3

Shell Scripting for Beginners

A command you can type in a terminal and a script you can hand to someone else are two different things. Shebangs and execute permission, quoting, set -euo pipefail, getopts, trap, locking, ShellCheck and bats. Twenty lessons that turn "a procedure only you can run" into "a script that does not break on someone else's machine".

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are grouped into five chapters. Working through them in order is the best way, but you are welcome to read only the part you are stuck on right now. Note: shell commands cannot run inside the browser. Try them in your own terminal (on macOS, Homebrew's bash 5.x).

Chapter 1 — Running it as a script (lessons 1–3)

What changes between typing at a terminal and writing a file you hand over. Shebangs and execute permission, quoting and word splitting, and set -euo pipefail. Get this wrong and the other seventeen lessons stay unstable.

1

The shebang and the execute bit

Line one's #! is read by the kernel — and macOS's /bin/bash is still the 2007 release.

Free
2

Variables and quoting

Drop the quotes and you get word splitting and globbing — watch a filename turn into a command-line option.

Free
3

Exit status and set -euo pipefail

A failed cd does not stop the next line — and the five places set -e does not help.

Free

Chapter 2 — Branching, looping and functions (lessons 4–6)

The difference between [ and [[, the trap waiting in while read when you go through a file line by line, and how far a variable leaks when you forget local. You meet the shell's "wrong but it still ran" cases first.

4

Conditionals, and why [[ 10 < 9 ]] is true

[ is a command, < inside [[ ]] compares strings, and (( )) reports failure when the result is zero.

🔒 Basic
5

Loops and reading files

Why four files iterate eight times, why the correct read loop is so long, and why find needs -print0.

🔒 Basic
6

Functions and scope

Variables are global by default, return only carries 0–255, and $(function) runs in a subshell.

🔒 Basic

Chapter 3 — Arguments and building up data (lessons 7–10)

The routes by which values reach a script from outside. Parsing options with getopts, using parameter expansion instead of calling an external command, arrays and associative arrays, and here documents.

7

Parsing arguments with getopts

$10 means ${1}0, the getopts format string and OPTIND, and the twenty lines that add --long options.

🔒 Basic
8

Parameter expansion

Doing without basename and sed — and why "$n）" comes out as mojibake.

🔒 Basic
9

Arrays and associative arrays

Building options as a string breaks — and forgetting declare -A silently turns your key into index 0.

🔒 Basic
10

Command substitution and here documents

echo "$(cmd)" swallows failures; <<EOF and <<'EOF' differ; and what <( ) actually is.

🔒 Basic

Chapter 4 — I/O, and the guards that keep it standing (lessons 11–15)

Opening file descriptors yourself, choosing between grep, sed and awk, cleaning up with mktemp and trap, designing logs, and stopping a second copy from starting. This is the chapter for scripts that run for a long time.

11

Redirection and file descriptors

Why 2>&1 > file does not work, and the design rule: logs to stderr, results to stdout.

🔒 Basic
12

grep, sed and awk

sed -i differs between GNU and BSD, and when three piped stages should become one awk.

🔒 Basic
13

Temporary files and trap

The five-line mktemp and trap ... EXIT idiom — and the fact that kill -9 runs no trap at all.

🔒 Basic
14

Error handling and logging

Print the failing line and the call path automatically — and note that ERR traps need set -E to reach functions.

🔒 Basic
15

Preventing concurrent runs

A counter that should reach 200 stops at 34 — and the lock built on mkdir being atomic.

🔒 Basic

Chapter 5 — Getting it ready to hand over (lessons 16–20)

Let machines read it with ShellCheck and shfmt, write tests with bats, check portability against dash, trace slowness back to subshells, and finally put it on a schedule with cron and a systemd timer.

16

ShellCheck and shfmt

A tool that flags nearly every pitfall from the last fifteen lessons — and why you read the wiki before writing disable.

🔒 Basic
17

Writing tests with bats

Make the script sourceable and you can call its functions — then watch calling main twice break it.

🔒 Basic
18

Portability and POSIX

#!/bin/sh is not bash — and why testing with sh on macOS proves nothing.

🔒 Basic
19

Performance and subshells

2000 calls to basename take 5621ms; ${path##*/} takes 7ms. And a check on "one awk is faster".

🔒 Basic
20

Packaging and scheduling

Splitting into bin/lib/test, wiring up a Makefile and CI, and running it from cron and a systemd timer.

🔒 Basic

Once you have finished all 20 lessons, turn to the servers your scripts will run on. Linux System Administration takes you into systemd and logs. If the commands themselves still feel shaky, go to Linux for Beginners. Membership unlocks every course.