Linux and Shell Fundamentals

The Linux Filesystem Model and Navigation

The single-rooted tree every Linux path describes, absolute versus relative paths, and the core commands for looking around and changing things safely.

Globbing, Quoting, and Expansion

How the shell rewrites what you typed before a command ever sees it — pattern matching, variable substitution, and the quoting rules that control exactly when that rewriting happens.

Standard Streams, Pipes, Redirection, and Exit Codes

The three data streams every command has by default, redirecting them to files, chaining commands with pipes, and the exit-code convention that lets one command react to another's success or failure.

Text Search and Transformation: grep, sed, and awk Foundations

Finding lines that match a pattern, and the two workhorse tools for transforming text at the line and field level — enough to be genuinely useful, not a complete reference.

sort, uniq, cut, head/tail, wc, and Archives

Six small, single-purpose utilities that combine into real, useful pipelines — plus tar's real relationship to compression, a genuinely common point of confusion.

Environment Variables, PATH, and Executable Files

The variables every process inherits, PATH's role in turning a bare command name into a real program, and what actually makes a file executable in the first place.

Processes, Signals, and Permissions

Inspecting and stopping running programs, the difference between asking a process to stop and forcing it, and the rwx permission model that governs who can do what to a file.

Shell Scripting: Parameters, Conditions, Loops, and Functions

Turning a sequence of commands you'd type by hand into a real, reusable script — parameters, conditionals, loops, and functions, the same building blocks as any programming language, applied to shell.

Defensive Scripting: set -e, set -u, and pipefail

Three options that make a script fail loudly and immediately instead of silently continuing after something goes wrong — and the real, specific limitations of set -e worth knowing precisely.

Temp Files, Cleanup Traps, and Logging

Creating scratch files safely with mktemp, guaranteeing cleanup even when a script fails partway through using trap, and writing logs that are actually useful for later debugging.

Catching Bugs Early: ShellCheck and Portability

How a static analyzer catches real shell scripting bugs before a script ever runs, and the specific portability traps that make a script behave differently across sh, bash, and different operating systems.

Running Scripts Unattended: cron and CI Execution

Why a script that works perfectly in an interactive terminal can behave differently when run unattended by cron or a CI pipeline, and how to write scripts that produce genuinely useful, actionable exit codes.

Networking Inspection and curl Fundamentals

Reading curl's output and exit codes to distinguish a network failure from an HTTP-level failure, and the core flags for making requests, following redirects, and inspecting responses from the command line.

Secrets, Command History, and Destructive-Command Safety

Why a password typed directly on the command line is a real secret-leak risk, how shell history quietly persists commands you've run, and habits that make a genuinely destructive command safer to author and run.