Bash Scripting Trainer

Where shell scripting belongs and where it does not. What the shell actually is relative to the kernel and the utilities it calls, what to expect from the course, and the prerequisites — then Git, because a script that is not in version control is an outage waiting to happen.

Topics: Why shell scripting, and where Python or Go is the better answer · Linux internals as the shell sees them — processes, streams, exit codes · What to expect from this course and its prerequisites · Git fundamentals: introduction and setup · Basic operations in Git for script repositories · GitHub and remote collaboration on shell code

• Assignments: (1) Set up a scripts repository with a sensible structure and a README; (2) Commit and push a first script with a meaningful history
• Capstone: Establish the versioned script repository you will build on for the rest of the course

From a command you typed once to a file someone else can run. Creating a script, the shebang and what the kernel does with it, permissions, how the script is located and called, naming conventions, and the type builtin for working out what a name actually resolves to.

Topics: Creating a shell script · A note-taking script, built live · Calling the script — path, PATH and the execute bit · The shebang and what the kernel does with it · Naming your script and avoiding collisions · The type command: builtin, alias, function or binary?

• Assignments: (1) Write and install a small utility script that runs from anywhere on PATH; (2) Determine, for ten names, whether each is a builtin, alias, function or binary
• Capstone: Ship a first script with a shebang, correct permissions and a usage message

Variables as Bash defines them — untyped strings until told otherwise — and the habits that stop them causing damage. Assignment and expansion, quoting discipline, reading input from a user or a file, and the debugging tools you will use for the rest of the course.

Topics: Variables: assignment, expansion and scope · Using variables in a script · Good habits — quoting, braces, naming, uppercase for exported only · Reading input with read · Debugging your script: set -x, set -e, set -u and PS4 · shellcheck as a standing check

• Assignments: (1) Fix a script that breaks on a filename containing a space; (2) Instrument a failing script with set -x and locate the failure
• Capstone: Adopt a strict-mode header and shellcheck-clean baseline for every script you write

Conditional logic in a language where truth is an exit status. The if statement and what it actually tests, return codes and $?, the conditional expression in both its forms, arithmetic tests, and the logical operators — including the precedence surprises that break real scripts.

Topics: The if statement and what it evaluates · Return codes, $? and exit status conventions · The conditional expression: test, [ ] and [[ ]] · String, file and existence tests · Arithmetic tests and (( )) · And, or, not — and operator precedence · The if statement revisited with strict mode

• Assignments: (1) Rewrite a chain of [ ] tests using [[ ]] and explain each behavioural difference; (2) Write a pre-flight check that exits with distinct codes per failure class
• Capstone: Build a pre-flight validation script that a deployment refuses to proceed without

Iteration and branching. While and until, the classic and C-style for statements, break and continue, the case statement for dispatch, and the && and || short-circuit forms — with a clear account of when they are readable and when they hide errors.

Topics: while and until · The classic for statement · The C-style for statement · break and continue · The case statement · && and || short-circuit evaluation · Looping over lines safely with while read

• Assignments: (1) Loop over a file of hostnames safely, handling spaces and blank lines; (2) Convert a nested if chain into a case dispatch
• Capstone: Write a retry-with-backoff loop that gives up cleanly and reports why

Controlling what a script says and where it says it. echo versus printf and why printf wins, read revisited for structured input, the three standard streams, redirection in all its forms, here-documents and here-strings, and separating machine-readable output from human commentary.

Topics: Output: echo and printf, and formatting with printf · Input: read revisited — IFS, -r, -t and delimiters · Standard streams: stdin, stdout, stderr · Redirection, appending and file descriptor duplication · Here-documents and here-strings · Process substitution · Logging to stderr so stdout stays parseable

• Assignments: (1) Rewrite a script so all diagnostics go to stderr and only data goes to stdout; (2) Use process substitution to compare the output of two commands without temp files
• Capstone: Produce a script whose output can be piped into another tool without post-processing

The typed side of an untyped language. Integer variables and arithmetic expressions, read-only variables, exporting and what a child process actually inherits, and indexed and associative arrays — the structure most shell scripts should be using and are not.

Topics: Integer variables and declare · Arithmetic expressions and (( )) · Arithmetic expansion versus expr and let · Read-only variables and constants · Exporting variables and the environment a child sees · Indexed arrays · Associative arrays · Subshells and why a variable set in a pipeline disappears

• Assignments: (1) Replace a set of numbered variables with an indexed array and iterate it correctly; (2) Explain and fix a counter that resets because it was incremented inside a pipeline
• Capstone: Build a configuration lookup using an associative array instead of repeated greps

Turning a script into a tool. Positional parameters, the special variables every script should handle, shift, and getopts for parsing options properly — including error handling, so an unknown flag produces usage output and a non-zero exit rather than silent misbehaviour.

Topics: Handling script parameters and positional arguments · Special variables: $0, $#, $@, $*, $?, $$, $! · "$@" versus "$*" and why the quoting matters · shift and consuming arguments · getopts for option parsing · getopts: handling errors and unknown options · Usage, help output and exit conventions

• Assignments: (1) Add getopts-based flags, defaults and a usage block to an existing script; (2) Handle an unknown option and a missing required argument correctly
• Capstone: Ship a script with a documented interface another team could adopt unchanged

Parameter expansion, which does most of what people spawn sed and cut for — faster and without a subprocess. Substring removal, search and replace, default and error values, pattern matching in the conditional expression, regular expression matching, and the end-of-options convention.

Topics: Fun with string parameters · Removing part of a string — prefix and suffix expansion · Search and replace within a variable · Setting a default value and failing on unset · Conditional expression patterns and globbing · Regular expressions in the conditional expression and BASH_REMATCH · End of options: -- and filenames that start with a dash

• Assignments: (1) Replace five external command calls with parameter expansion and measure the difference; (2) Parse a semantic version string using only builtin expansion
• Capstone: Write a filename and path handling library that survives spaces, dashes and unicode

Structuring a script that has outgrown a single flow. Defining and calling functions, arguments and local variables, return values versus output, sourcing a shared library, and the conventions that keep a growing shell codebase readable — plus the miscellaneous behaviours that surprise people.

Topics: Shell functions: definition, calling and arguments · local variables and why they are not the default · Returning status versus emitting output · Sourcing a shared function library · Recursion and its limits in shell · Miscellaneous remarks — aliases, builtins and command lookup order

• Assignments: (1) Extract repeated logic from three scripts into a sourced function library; (2) Write a logging function with levels used consistently across a script
• Capstone: Build a reusable shell library with functions for logging, validation and cleanup

Where the script actually executes, and what changes when it does. The several ways to invoke a script and how each affects the environment, background execution and nohup, exec, scheduling with at and cron, and the shell options that make behaviour deterministic across machines.

Topics: Many ways to run your script — sh, source, ., exec, subshell · Running your code in the background · nohup and detaching from the terminal · exec and replacing the process image · at and cron for scheduled execution · set and shopt — making behaviour explicit rather than inherited · traps and guaranteed cleanup on exit or signal · Locking so two copies never run at once

• Assignments: (1) Add a trap-based cleanup and a lock file to a long-running script; (2) Schedule a job under cron and fix the PATH and environment differences that break it
• Capstone: Deploy a scheduled, locked, trap-protected script that logs and alerts on failure