Linux & the Command Line — from first command to confident operator

Sooner or later every developer meets a black window with a blinking cursor: a server to configure, a Raspberry Pi to set up, a build to run, a tool with no buttons. This path makes that window feel like home. Start with what Linux even is and why the command line is worth learning, then build up one small, safe command at a time — moving around the filesystem, managing files, permissions, and processes, and installing software. From there you'll learn the real superpower of the shell — pipes and text tools that snap together into custom commands — write your first scripts to automate the boring parts, and finish able to run and maintain your own services over SSH, including GopherTrunk itself on a Linux box or an SBC. No prior command-line experience required; examples use Linux (with notes for macOS and Windows/WSL).

Start lesson 1 →Jump to glossary

Sooner or later every developer meets a black window with a blinking cursor: a server to configure, a Raspberry Pi to set up, a build to run, a tool with no buttons. This path makes that window feel like home. We start from what Linux even is and build, one small and safe command at a time, until you can run and maintain your own services — including GopherTrunk on a Linux box or a single-board computer by the antenna.

Who this is for. Complete newcomers to the command line are welcome — no prior terminal experience assumed. If you already know your way around a shell, use the module list to jump straight to the gaps (permissions, scripting, systemd). Every lesson is short, hands-on, and cross-linked.

How the path works. Six modules take you from first principles to a running service. The early modules are the foundations — the shell, the filesystem, permissions, and processes — knowledge that applies to any Unix-like system. The middle modules unlock the shell’s real power (pipes and text tools) and turn your commands into scripts. The last module puts it all to work on real machines: SSH, systemd services, monitoring, and a full walkthrough of running GopherTrunk on Linux. Examples use Linux, with notes for macOS and Windows (WSL). Mark lessons complete as you go — your progress is saved in your browser. New here? Start with lesson 1: What is Linux?

Module 1 — Getting Started with Linux & the Shell

What Linux is, why the command line is worth your time, and how to open a shell and run your very first commands without fear.

  1. What is Linux? The kernel, the distributions, and why Linux quietly runs the servers, phones, and single-board computers the world depends on. beginner 8 min
  2. Why the command line? What a terminal gives you that a mouse can't — speed, precision, remote control, and automation — and why it's still essential. beginner 8 min
  3. The shell explained What the shell actually is, the prompt, and the command-arguments-options pattern behind everything you'll type. beginner 9 min
  4. Getting a shell Opening a terminal on Linux, macOS, and Windows (WSL), plus reaching one on a server or a Raspberry Pi. beginner 8 min
  5. Your first commands pwd, ls, cd, and echo — moving around and looking about — plus how to ask any command for help. beginner 9 min

Module 2 — Files & the Filesystem

Everything on Linux is a file in one big tree. Learn to navigate it, and to create, view, edit, and find files with confidence.

  1. The filesystem hierarchy One tree from /, the folders that matter (/home, /etc, /var), and absolute vs. relative paths. beginner 9 min
  2. Navigating & listing files Moving around with cd, reading ls in detail, hidden files, and seeing the shape of a directory tree. beginner 8 min
  3. Creating, copying & moving files mkdir, touch, cp, mv, and rm — building and rearranging files and folders, and why rm has no undo. beginner 9 min
  4. Viewing & editing files cat, less, head, and tail for reading, plus a gentle first look at editing in nano and vim. beginner 9 min
  5. Finding files & text Locating files with find, searching inside them with grep, and finding a command with which and locate. intermediate 9 min

Module 3 — Permissions, Users & Processes

Who can do what, and what's running right now: the multi-user model, file permissions, root, and managing live processes.

  1. Users, groups & root Linux as a multi-user system — accounts, groups, and the all-powerful root user you should mostly avoid being. beginner 8 min
  2. File permissions Read, write, execute for user, group, and other — reading ls -l, and changing access with chmod and chown. intermediate 10 min
  3. sudo & becoming root safely Why you don't log in as root — using sudo to borrow admin power for one command, and the habits that keep you safe. intermediate 8 min
  4. Processes & jobs What a process is, watching them with ps and top, foreground vs. background jobs, and stopping one with signals. intermediate 10 min
  5. Installing software with a package manager apt, dnf, and pacman — how Linux installs, updates, and removes software from trusted repositories instead of downloads. beginner 9 min

Module 4 — The Power of the Command Line

The real superpower: small tools that snap together. Pipes, redirection, text processing, wildcards, and the environment.

  1. Pipes & redirection stdin, stdout, and stderr — sending one command's output into another with |, and to and from files with > and <. intermediate 10 min
  2. Text-processing tools grep, sort, uniq, wc, cut, and a taste of sed and awk — the toolkit that turns raw text into answers. intermediate 11 min
  3. Wildcards, globbing & expansion How the shell expands *, ?, and {…} before a command runs, and why quoting sometimes matters. intermediate 9 min
  4. Environment variables & PATH What environment variables are, why PATH decides which programs you can run, and how to set them for a session or for good. intermediate 9 min
  5. History, tab completion & shortcuts Command history, reverse-search, tab completion, and the keyboard shortcuts that make the shell fast. beginner 8 min

Module 5 — Scripting & Automation

Turn a sequence of commands into a reusable program: your first scripts, variables and input, control flow, and scheduling.

  1. Your first shell script The shebang line, making a file executable, and running a saved sequence of commands as a program. intermediate 9 min
  2. Variables, arguments & input Storing values, reading script arguments, and taking input — the pieces that make a script flexible. intermediate 9 min
  3. Conditionals & loops if, for, and while with the test command — making a script decide and repeat instead of running blindly. intermediate 10 min
  4. Functions, exit codes & error handling Reusable functions, the exit codes every command returns, and writing scripts that fail loudly instead of silently. advanced 10 min
  5. Scheduling with cron & timers Running a job every night or every minute — cron syntax, systemd timers, and where scheduled output goes. intermediate 9 min

Module 6 — Living on Linux: Servers, SBCs & GopherTrunk

Everything applied: reach a machine over SSH, run software as a managed service, watch its health, and put GopherTrunk on a Linux box.

  1. SSH & working remotely Logging into another machine over the network with SSH, key-based login, and copying files with scp. intermediate 10 min
  2. Services & systemd How Linux runs background services — systemctl to start and enable them, and journalctl to read their logs. advanced 10 min
  3. Monitoring, disk & logs Checking disk with df and du, memory and load with free and htop, and finding out what went wrong in the logs. intermediate 9 min
  4. Running GopherTrunk on Linux Putting it all together — installing GopherTrunk, running it, and keeping it alive as a service on a Linux box or a Raspberry Pi. intermediate 10 min
  1. Glossary of Linux & command-line terms Plain-language definitions for every term in the path — shell, kernel, path, permission, process, pipe, PATH, script, cron, SSH, systemd, and more — cross-linked to the lessons.