Linux

Before you type a single command, understand what Linux is and why DevOps engineers use it every day.

Understand what the black rectangle full of text actually is, and why engineers prefer it to clicking icons.

Decode `learner@dlth:~$`. Each piece tells you something useful before you type a single command.

Linux organises every file in a single tree starting at `/`. See it once and the layout makes sense forever.

A command is just a program the shell finds on a list of folders called PATH. Once you see that, the magic dissolves.

Print the absolute path of the directory the shell is in. The first thing to ask before you do anything else.

Three flavours of ls. Bare for a quick look, `-l` for details, `-a` for hidden files.

Walk between directories with cd, climb with cd .., go home with cd ~.

Filenames that start with a dot are hidden from default `ls`. Reveal them with `ls -a`. The convention covers `.bashrc`, `.ssh/`, `.git/`, `.env`.

Use `file` to identify what something actually is by inspecting magic bytes. Saves you from `cat`-ing a binary and garbling your terminal.

Four ways to read a file. Pick the one that matches the file's size and your intent.

`less` is a pager. Open a long file, scroll, search forward with `/`, jump matches with `n`, quit with `q`. Stops `cat` from flooding your terminal.

Watch a log file as new lines arrive. The `-f` flag keeps the file open and streams updates in real time.

Create directories. Plain mkdir for one. mkdir -p for nested paths in a single shot.

Create empty files. The simplest building block for everything else you'll do with text on Linux.

Two operators that write text to files without opening an editor. The fastest way to script file content.

Locate files anywhere on disk by name, type, or modification time. The 'where did I put that' command.

Use `find -mtime` to filter by age and `-size` to filter by file size. The two tests that drive most disk-cleanup scripts.

find locates files; grep looks INSIDE them. Plain grep for one file, grep -r for a tree.

Show lines around a match with -A and -B. Match case-insensitively with -i. The flags that turn grep from finder into reader.

Nano is the friendly terminal editor. Type, Ctrl+O to save, Ctrl+X to exit. That's the whole story.

Just enough vim to open a file, edit it, save, and quit. Not a vim course, a not-getting-stuck course.

Duplicate a file with cp. Rename or relocate one with mv. The first leaves the source; the second doesn't.

Remove files with rm. Understand what -r and -f mean. The single command engineers most regret typing.

Bundle a directory into a single `.tar.gz` file, then extract it back. The standard way to ship code, configs, and backups on Linux.

The 10-character string at the start of `ls -l` tells you who can do what. Learn to read it before you change it.

Three octal digits. Owner, group, others. The fastest way to set permissions exactly the way you want.

Symbolic mode uses letters: u (user), g (group), o (others), + (add), - (remove). When you only want to flip one bit, this is faster than numeric.

Read user and group ownership from `ls -l`, try `chown` without root to see why it fails, and use `chgrp` to switch a file's group.

Write a tiny shell script, set the execute bit with chmod +x, and run it. The full lifecycle of a Unix program from your fingertips.

Every process on the box, with its user, CPU, memory, and command line. The first thing to run when something feels wrong.

Send a long-running command to the background with &, list it with jobs, bring it back with fg.

Start a background job that survives the shell closing. Use `nohup` to ignore SIGHUP, and `disown` to drop a running job from the shell's job table.

Send a signal with kill. Default is TERM (polite). Escalate to KILL with -9 when the process ignores you.

Every process has a parent. The tree view shows you who started what.

Every program has three streams. Once you can name them, redirection and pipes stop being magic.

Stream output to files. > overwrites, >> appends, 2>&1 captures errors.

Send the output of one command as the input of the next. The vertical bar that turns Unix into Lego.

The classic 'cat file | grep pattern' combo. The shape of every Unix one-liner you'll write for the rest of your career.

Pipe through wc, redirect the count to a file. Two operators stacked, one of the most common shell shapes.

Three commands that turn pipes into real analysis. Count lines. Sort them. Deduplicate. The 'top N requesters' one-liner is built from these.

cut extracts specific columns or characters. tr translates one set of characters into another. Two surgical tools for cleaning data.

Find-and-replace text without opening an editor. The most common shell one-liner pattern of all time.

awk treats each line as a row of fields. Pull columns, do math, filter rows. The Unix one-liner secret weapon.

Send the same output to a file AND to the next pipe stage. Useful for logging mid-pipeline and for sudo-write tricks.

Three commands answer 'is this box healthy.' df for filesystems, du for what's eating disk, free for memory.

Three commands tell you what kernel you're on, how long the box has been up, and who else is logged in.

Environment variables are how processes inherit context. $PATH tells the shell where to find commands. env shows them all.

A plain assignment lives in the current shell only. export hands a variable down to child processes. ~/.bashrc is what makes it survive a new shell.

Single quotes are literal. Double quotes expand $VAR and $(cmd). Backticks run a command and substitute its output. Most bash bugs in the wild are wrong-quote bugs.

Glob patterns are expanded by the shell before the command runs. The kernel never sees a glob. Quoting disables it.

Bash has a small set of expansion forms that show up in every script. Defaults, suffix and prefix trimming, last exit code, and the current PID.

A script refuses to run with permission denied. Read the permission bits to find why, fix the one that is wrong, and make the script produce its output.

A background job is filling a log file and will not stop on its own. Find which process is writing it, identify it, and kill it.

An open-ended problem with no prescribed pipeline. Read an access log, count requests and errors per client IP, and write a sorted CSV. Any approach that produces the right report passes, the checks grade the output, not the keystrokes.