Glossary

155 terms from Operating System Basics, in plain words, each with the chapter that teaches it.

Search the glossary

#

$?: A shell variable that holds the exit code of the last command. `echo $?` after `./health.sh` shows 1 when the script found a warning.
..: Short path names: `..` means the folder one level up, and `.` means the folder you're in now. `cd ..` takes you up one folder.
/proc: A folder of files the kernel makes up when you read them, showing information about processes and the system. `health.sh` reads the load from `/proc/loadavg` and memory from `/proc/meminfo`. `/dev` and `/sys` work the same way.
/var/log: The standard Linux folder where the system and older programs keep their plain-text log files, which you read with `tail` and `grep` when troubleshooting. A huge log file left there, such as a 901 MiB export log, can fill a machine's disk.
3-2-1 rule: A backup plan: keep three copies of your data, on two different kinds of media, with one copy off site. Kettle & Crane backs up nightly to an office RAID box and to an online service.

A

absolute path: A path that starts at the root folder `/`, such as `/home/ubuntu/work`. It points to the same place wherever you are.
Activity Monitor: The macOS app, in Applications, Utilities, that shows running processes and their CPU and memory use, including a Memory Pressure graph. It's the Mac's version of Task Manager.
apt: Ubuntu's package manager. `sudo apt install strace` adds a program, `sudo apt update` refreshes the list of available packages, and `sudo apt upgrade -y` installs all waiting updates.
archive: A single file that holds many files and folders. Alex's daily backup `kc-2026-11-01.tgz`, made with `tar`, is one.
arguments: The part of a command that says what to work on, usually a file or folder name. In `ls -l /etc/hostname`, the argument is `/etc/hostname`.
available: The column in `free` that shows how much RAM programs could still get, counting cache the OS would hand back. Watch this column, not `free`: the order machine had little `free` but plenty `available`.
awk: A small tool that picks fields out of lines of text. `awk '/^MemTotal/ {print $2}' /proc/meminfo` prints the second field of the MemTotal line.

B

bash: The default shell on Linux: the program that reads the commands you type and runs scripts that start with `#!/bin/bash`.
BitLocker: The disk encryption built into Windows 11 Pro. It's one reason Kettle & Crane buys the Pro edition.
blue screen: What Windows shows when the kernel or a driver crashes. The stop code on the screen hints at the cause, often a bad driver.
bootloader: The small program the firmware starts, which then loads the OS kernel. Its boot menu can offer a choice of systems or older kernels.
buff/cache: RAM the OS borrows to keep copies of recently read files so they read faster. It's given back the moment a program needs it.

C

case-sensitive: When upper and lower case count as different. On Linux, `Report.txt` and `report.txt` are two files; on Windows and macOS they're the same file.
cat: Prints the whole of a file, which suits short files. `cat > show.py` can also create a file from what you type, ended with Ctrl+D.
cd: Changes your working directory, as in `cd work/labels`. `cd ..` goes up one folder, and `cd` on its own goes back home.
checksum: A long number calculated from every byte of a file. Any change, even a few bytes, gives a completely different number, so it proves a download or backup copy is undamaged.
chmod: Changes a file's permissions, either with letters (`chmod u+x report.sh`) or with numbers (`chmod 750`, where r=4, w=2 and x=1 for each set).
chown: Gives a file or folder to another owner and group, written `user:group`. It needs sudo, as in `sudo chown root:shipping /srv/shipping`.
clean boot: Starting Windows with all non-Microsoft services and startup apps switched off (in msconfig and Task Manager), to narrow down which one causes a problem.
command: The first word on a command line: the program to run, such as `ls`. It can be followed by options and arguments.
context switch: When the kernel stops one thread, saves its registers, and loads another thread's so it can run. It happens hundreds of times a second.
cp: Copies a file, as in `cp orders.log work/orders-backup.log`. It replaces an existing file with the same name without asking unless you add `-i`.

D

Device Manager: The Windows tool that lists every device and its driver. A yellow triangle means the driver is missing or broken, and the Driver tab can update or roll it back.
df: Shows how full each file system is. Watch its `Use%` column; `df -h /` showed 100% when Sam's orders wouldn't save.
directories: Folders: containers in the file tree that hold files and other folders.
distribution: The Linux kernel bundled and tested with a shell, tools, a desktop and a way to install software. Ubuntu, Debian, Fedora and RHEL are all distributions.
driver: A program that lets the OS talk to one kind of device, such as the shipping room's label printer. Drivers run inside the kernel, so a bad one can crash the whole machine.
du: Adds up the size of files and folders. `du -sh /var/log/* | sort -h | tail -3` found the 901 MiB export log that filled the order machine's disk.
dual boot: Two operating systems installed on one machine, with the bootloader offering a menu at start-up. For trying another OS, a VM is simpler and safer.

E

Event Viewer: The Windows app that holds the system and application logs. You can filter it to show only errors, each with a source, an ID and a message.
exit code: The number a program ends with: 0 means success and anything else means a problem. `health.sh` exits with 1 when it found a warning, so other tools can react.
ext4: The main file system used by Linux.

F

file: A command that looks inside a file and says what kind it is, whatever its name says. For example, `orders.log` is 'CSV ASCII text'.
file descriptor: A small number the kernel gives a program for an open file, such as 3 for `order.txt`. Numbers 0, 1 and 2 are standard input, output and error.
file system: The way a drive or partition organizes its storage into files and folders. Linux mainly uses ext4, Windows NTFS and macOS APFS.
find: Searches a folder and every folder inside it for matching names, as in `find work -name '*.pdf'`. Quote the pattern so the shell doesn't expand it first.
free: Shows RAM and swap use. Its `available` column, not its `free` column, tells you whether a machine is really short of memory.
functions: Named blocks of commands in a script that you run by name, like small commands of your own. `health.sh` defines `ok` and `warn`, and `$1` is the first value passed to them.

G

GPT: GPT (GUID Partition Table) is the table the installer writes at the start of a drive to list its partitions.
grep: Prints only the lines that contain a word, as in `grep FAILED orders.log`. `-c` counts the lines, `-i` ignores case, and `-E` allows patterns such as `vmx|svm`.
groups: Named sets of users who share permissions. Priya and Alex are in the `shipping` group, so both can use `/srv/shipping`; Jo isn't, so Jo can't.

H

hidden files: Files whose names start with a dot, such as `.bashrc`. `ls` leaves them out unless you add `-a`.
history: Lists the commands you've typed, numbered. The Up arrow brings them back one at a time.
home folder: Each user's own folder, such as `/home/ubuntu` on Linux, `C:\Users\Priya` on Windows or `/Users/jo` on a Mac. `~` is shorthand for it.
host, guest: The host is the real machine; a guest is a VM running on it. Your laptop is the host for the `lab` VM.
hypervisor: The program that runs virtual machines and shares out the real CPU, RAM and storage to them. Type 2 runs as an app on a normal OS (VirtualBox); type 1 runs directly on the hardware (ESXi, KVM).

I

id: Shows a user's UID, main group and all their groups, as in `id priya`.
if: A script statement that runs the commands after `then` when a test is true and the ones after `else` when it's false; `fi` ends it. `health.sh` uses it to choose OK or WARN.
inheritance: On Windows NTFS, folders pass their permissions down to everything inside them, so you usually set permissions once on the top folder.
ISO: A single file holding a copy of a whole install disc, such as the Ubuntu or Windows 11 installer. Check its checksum before you use it.

J

jobs: Lists the shell's background and stopped jobs. `%1` refers to job 1, as in `kill %1`.
journal: systemd's central collection of log messages from services and the OS, read with `journalctl`.
journalctl: Reads the systemd journal. `journalctl -p err -b` shows errors since this boot, and `-u cron` shows one service's messages.

K

kernel: The core of the OS and the one program with full control of the hardware. Every other program has to ask it for help through system calls.
kernel mode: The CPU mode in which the hardware limits are lifted, used while the kernel handles a system call. Programs normally run in the limited user mode.
kernel modules: Linux drivers kept as separate files and loaded when their device is found. `lsmod` lists the loaded ones.
kernel panic: A crash of the kernel itself on Linux or macOS, which stops the whole machine. Windows shows a blue screen instead.
kill: Sends a signal to a process: plain `kill PID` asks it politely to exit (TERM), and `kill -9` forces it to end at once (KILL). Alex used `sudo kill` on Sam's stuck script.

L

ladder of fixes: An order for trying software fixes from least to most disruptive: restart the app, read the logs, undo the last change, start in a reduced mode (Safe Mode or a clean boot), then reinstall or restore from backup. You stop at the first step that solves the problem.
less: Shows a long file one screen at a time. Space goes down a page, `/word` searches, and `q` quits.
Linux: A Unix-like OS kernel that runs most servers and the cloud, plus Android phones. Kettle & Crane's order machine runs it as Ubuntu.
load average: How many threads were running or waiting for a CPU, averaged over the last 1, 5 and 15 minutes. Compare it with the number of cores: a load of 1 on the 2-core order machine means one core is fully busy.
logs: Records of what programs and the OS did and what went wrong. They're the first place to look for evidence when troubleshooting.
ls: Lists files. `-l` shows permissions, owner, size and date; `-a` includes hidden files; `-h` gives readable sizes; and `-d` shows a folder itself rather than what's inside it.
LTS: LTS (long-term support) is an Ubuntu release that gets five years of security updates, such as 26.04 LTS. Offices and servers use LTS releases so they don't have to upgrade often.

M

man: Opens a command's full manual page, as in `man ls`. Scroll with the arrow keys and press `q` to quit.
memory leak: A bug where a program's memory keeps growing over time until the program is killed or the machine runs short.
mkdir: Makes a folder. With `-p` it also makes any missing parent folders, as in `mkdir -p work/labels`.
mounting: Attaching a drive at a folder somewhere in Linux's single file tree, instead of giving it a drive letter.
mv: Moves a file, or renames it when the destination is in the same folder. Like `cp`, it replaces an existing file without asking unless you add `-i`.

N

nano: A simple text editor that runs in the terminal. Ctrl+O saves and Ctrl+X quits.
netplan: The Ubuntu service that sets up the network. Its failure on the test machine is harmless there but would be the first clue to a network problem on a real server.
NT kernel: The kernel of Windows, first released in 1993.
NTFS: NTFS (New Technology File System) is Windows' main file system. It keeps a permission list for each file and folder, shown on the Security tab.

O

OOM killer: The Linux feature that ends the process using the most memory with KILL when RAM and swap both run out, so the rest of the machine survives.
operating system: The software that shares a computer's CPU time, memory, files, users and devices fairly and safely among programs. Windows, macOS and Linux are operating systems.
options: Letters after `-` or words after `--` that change how a command works, such as `-l` or `--all`. Short options can be joined, so `ls -la` means `ls -l -a`.
owner, group, others: The three sets of permissions on a Linux file: one for its owner, one for its group, and one for everyone else. Jo falls under 'others' for `/srv/shipping`, which gets no access.

P

package: A program packed with everything needed to install it, such as Ubuntu's `nano` package.
package manager: A tool that downloads packages from trusted servers, installs them, and updates them all at once, such as `apt` on Ubuntu or `winget` on Windows.
page file: Windows' version of swap: the file `pagefile.sys` on drive C:, where idle memory pages go when RAM is full.
pages: The 4 KiB pieces the OS splits memory into. The OS keeps a table of where each process's pages sit in RAM, or out in swap.
parent: The process that started another one; its PID is shown as PPID. Every service's parent is systemd, PID 1.
partition: A separate section of a drive with its own file system. The installer creates partitions for you.
patch: An update that fixes a bug, often a security hole. Attackers study patches to target machines that haven't installed them yet, so install updates promptly.
Patch Tuesday: The second Tuesday of each month, when Windows gets its big monthly batch of updates.
path: The name of a file given by the folders that lead to it, separated by `/` on Linux and Mac (`/home/priya/notes.txt`) or by `\` on Windows (`C:\Users\Priya\notes.txt`).
permissions: The rules for who may read (r), write (w) and execute (x) a file. `ls -l` shows them as ten characters, such as `-rw-r--r--`.
PID: PID (process ID) is the number that identifies a running process. systemd's PID is always 1.
pipe: The `|` symbol, which sends one command's output into the next command. Alex's `grep FAILED orders.log | cut -d , -f 2 | sort | uniq -c` chains four commands this way.
PowerShell: Windows' command-line shell. Its commands have longer verb-noun names, such as `Get-Process`, but use the same ideas as bash.
process: A running program, with its own code, private memory, open files and PID. Running the same program twice gives two processes.
process state: The letter `ps` shows for what a process is doing: R running, S sleeping, D waiting for the disk, T stopped, Z zombie.
ps: Lists processes. `ps -eo pid,user,%cpu,%mem,comm --sort=-%cpu` shows every process, busiest first.
pwd: Prints the folder you're in now, your working directory.

R

RAID: Several drives working as one, so the data survives a dead drive. It copies deletions and ransomware damage to every drive too, so it's not a backup.
ransomware: Malware that scrambles your files and demands payment to unscramble them. A backup kept apart from the machine is the cure.
redirection: Sending a program's output somewhere other than the screen: `>` replaces a file's contents, `>>` adds to the end, and `2>` sends error messages to a file.
Registry: The database where Windows keeps most of its settings. You change it through Settings, or with the Registry Editor (`regedit`) only when a Microsoft guide tells you to.
relative path: A path that starts from your working directory. From `/home/ubuntu`, `work` means `/home/ubuntu/work`.
Reliability Monitor: A Windows timeline with a column per day, showing crashes as red crosses and updates and installs as blue marks. It makes 'what changed?' easy to answer.
repositories: The download servers that hold packages for a package manager, such as Ubuntu's main, updates and security repositories.
rm: Deletes files at once, with no recycle bin. `rm -r` deletes a folder and everything in it, so check the same pattern with `ls` first.
root: Two meanings: the top folder `/` of the Linux file tree, and the all-powerful administrator account (UID 0), which you use through `sudo`.
RSS: RSS (resident set size) is the RAM a process really uses, in KiB. `ps --sort=-rss` showed `hog.py` using just over 1 GiB.
runaway: A process that keeps using the CPU and never stops, like Sam's forgotten report script stuck in a loop at 99% CPU.

S

Safe Mode: Windows started with only basic drivers and no startup apps. If a problem disappears there, something that normally loads is causing it.
scheduler: The part of the kernel that decides which thread runs on which core and for how long, giving each one short time slices.
script: A text file of commands that run one after another, such as `report.sh` or `health.sh`. You run it with `bash report.sh`, or as `./report.sh` once it has `x` permission.
Secure Boot: A firmware feature that Windows 11 requires, which checks that only trusted bootloaders start.
services: Programs that run in the background with no window, such as `cron` or `rsyslog`. systemd starts them at boot.
shebang: A script's first line, `#!/bin/bash`, which names the program that runs the script.
shell: The program that reads and runs the commands you type: bash on Linux, zsh on macOS, PowerShell on Windows.
signal: A short message the kernel delivers to a process. TERM asks it to exit, KILL ends it at once, INT comes from Ctrl+C, and TSTP from Ctrl+Z.
six-step method: The troubleshooting method: identify the problem, establish a theory, test it, plan and fix, verify, and document. Alex used it when orders wouldn't save.
SMART: A drive's own health records: hours used, bad sectors, temperature and SSD wear. A FAILED result means copy the data off and replace the drive.
snapshot: A saved state of a VM's drive and settings that you can return to in seconds. Alex took one before testing the order system's update. It isn't a backup, because it's stored on the same drive as the VM.
standard output: A program's three standard channels: input (0, the keyboard), output (1, the screen) and error (2, the screen, for error messages). Redirection can send each of them elsewhere.
strace: Runs a program and records every system call it makes. Tracing `show.py` revealed the `openat`, `read`, `close` and `write` calls behind it.
sudo: Runs one command with root's power, after asking for your own password. Only members of the `sudo` group may use it, and `sudo -u priya` runs a command as Priya instead.
swap: Disk space Linux uses as overflow, moving idle memory pages there when RAM is full. It prevents crashes but is far slower than RAM.
sync: A service such as OneDrive or iCloud Drive that keeps the same files on every device. Deletions and damage sync too, so it isn't a full backup.
system call: A program's request to the kernel, such as opening, reading or writing a file. Programs can't touch the hardware themselves, so they must ask this way.
systemctl: Controls and lists systemd services. `systemctl --failed` shows the services that failed to start.
systemd: The first program the Linux kernel starts (PID 1). It starts all the services and collects their logs in the journal.

T

tar: Packs files into a single archive and unpacks it again. `-c` creates, `-t` lists, `-x` extracts, `-z` compresses, `-f` names the file, and `-C` picks the folder to restore into.
target: A group of systemd services that marks a stage of start-up. `graphical.target` means the machine is ready, with a graphical login if one is installed.
Task Manager: The Windows app (Ctrl+Shift+Esc) that shows processes, CPU and memory use, and startup apps, and can end a stuck program.
thrashing: Constant swapping when RAM is full: the disk stays busy and every click takes seconds. The cure is more RAM or fewer programs at once.
thread: One path of work inside a process. Threads in the same process share its memory; a web browser uses several at once.
time slice: The few milliseconds a thread is allowed to run before the scheduler switches to another one.
top: Shows the busiest processes and updates every few seconds. Its summary splits CPU time into user (`us`), kernel (`sy`), idle (`id`) and disk waiting (`wa`).
TPM 2.0: TPM (Trusted Platform Module) is a security chip feature that Windows 11 requires, along with UEFI and Secure Boot.

U

UAC: UAC (User Account Control) is the Windows prompt that dims the screen and asks before a program makes admin changes. It's Windows' version of sudo.
Ubuntu: A popular free Linux distribution made by Canonical and built from Debian, with a new release every six months and an LTS release with five years of updates every two years. Kettle & Crane's order machine runs Ubuntu 26.04 LTS.
UEFI: UEFI (Unified Extensible Firmware Interface) is the modern PC firmware that starts the bootloader. Windows 11 requires it.
UID: UID (user ID) is a user's number. The kernel stores only numbers; root's UID is 0, and Priya's is 1001.
Unix: An operating system written at Bell Labs in 1969. macOS descends from it, and Linux works the same way without sharing its code, so Linux is called Unix-like.
user: An account that processes run as and files belong to. The OS checks the user at every system call to decide what's allowed.
user space: Where ordinary programs run, from the shell to the browser. The CPU stops them from touching the hardware or other programs' memory directly.

V

variable: A named value in the shell or a script, set with `cafe="Hearth"` (no spaces around `=`) and used as `$cafe`. Double quotes replace variables; single quotes don't.
virtual machine: A VM is a computer that runs as a program inside another computer, like your Multipass `lab`. VMs let Alex test risky changes safely.
virtual memory: Each process's own private set of memory addresses, which the OS maps to real RAM page by page. It keeps processes apart and lets the OS move pages around.

W

wildcard: A pattern character in file names: `*` matches any characters and `?` matches exactly one. `label-2025-*.pdf` matched all of last year's labels.
Windows Update: The Windows Settings page that installs system updates and most drivers. Its Update history shows what was installed and when.
working directory: The folder you're in right now. Relative paths start from it, and `pwd` prints it.
WSL: WSL (Windows Subsystem for Linux) runs Linux inside Windows 11. You install it with `wsl --install` in an administrator terminal.

X

XNU: The kernel of macOS, descended from Unix.

Z

zombie: A process that has finished but whose parent hasn't collected its result yet. It uses no memory.
zsh: The Z shell, the default command-line shell on macOS. For everyday commands, pipes and scripts it works almost exactly like bash.