Start Here

New to Linux? Read these five, in this order. About two hours in total, and they cover the ninety per cent of day-to-day Linux that everything else assumes you already know.

1. Command line basics — wildcards, quoting, pipes and redirection, which are the four things every later page assumes.
2. The Linux filesystem — what every top-level directory is for, so you stop guessing where things live.
3. File permissions — the nine bits, ownership, and what chmod 777 actually does to you.
4. What a shell actually is — which startup file runs when, and why your alias vanishes over SSH.
5. systemctl — starting, stopping and inspecting services, which is most of what running a Linux machine consists of.

After those, follow whatever you are actually trying to do. There is no curriculum here and no order you are supposed to go in.

The long reads. A handful of pages go considerably deeper than everything else. Each follows one thing through its entire path — stage by stage, in the order it actually happens — shows the command that inspects each stage, and ends with a worked diagnosis rather than a summary.

They take half an hour rather than five minutes. They are the ones to read when you want to stop guessing at a whole class of problem for good.

• From Power-On to a Login Prompt — the eight handoffs between the power button and a shell, and how to tell which one failed
• The Shell, in Depth — the eleven stages between pressing Enter and an exit status, and why quoting bugs are invisible
• Containers, All the Way Down — the nine stages between docker run and a running process, and why there is no such thing as a container
• What Ships in Your Container Image — the seven stages between the build that made an image and the moment nobody can account for it, and why deleting a file does not unpublish it
• The Life of a Package — the eight stages between apt install and working software, and why the two package families do the same job in the opposite order
• Memory, All the Way Down — the eight stages between malloc and the OOM killer, and why free is not the number to look at
• Permissions and Privilege, Properly — the six independent layers between a process and a file, in the order the kernel checks them
• The Life of a Login — the seven stages between a password and a shell, and why having a shell proves less than you think
• The Life of a Write — the seven layers between write() returning and the data actually existing
• How Time Works on a Linux Machine — the seven stages between the clock nobody is keeping and somebody else’s tolerance, and why every timestamp on the machine is true and no two of them are necessarily comparable
• The Life of a System Call — the seven stages between the name you wrote and the answer your program believes, and why four different things can answer for the kernel
• The Life of a File Descriptor — the seven stages between open() and close(), and why closing something rarely closes it
• How a Path Becomes a File — the six stages between a pathname and an open file, and why the same string can name two different things
• The Life of a Unix Socket — the seven stages between a socket with no name and a name with no socket, and why every tool on the machine repeats a path none of them has checked
• DNS, All the Way Down — the eight stages between getaddrinfo and an address, and why dig cannot see the first three of them
• The Life of a Packet — everything between your application’s write() and the wire, and back again
• What Happens When You Type a URL — the six stages between a keystroke and a response, and why most of them finish before a packet exists
• The Life of a Log Line — the seven stages between a program’s own buffer and the party who has to be convinced, and why every field in the record was written by somebody different
• The Life of a Scheduled Job — the eight stages between the line you wrote and the person who needed last night’s output, and why a job that ran and did nothing is green on every instrument the machine has
• The Life of a Block Device — the eight stages between the kernel noticing a disk and the other copy of it somewhere else, and why no name your disk has is both stable across a move and unique across a copy

Nine of them are practical rather than explanatory, and live in Guides:

• Running PostgreSQL Properly — the eight stages between a client sending COMMIT and data you could still restore a year later
• Kubernetes, Honestly — the seven stages between kubectl apply and a running container, and why nothing in the middle is ever sent anywhere
• etcd, Honestly — the six stages between the member that answered your write and a restore, and why a restore that reports success can quietly break every controller you have
• The Life of a Certificate — the six stages between an ACME account and a certificate your server is actually serving, and why a renewal that succeeds proves less than you think
• The Half of Patching That Happens After the File Is Correct — the seven stages between a security advisory and a machine you can vouch for, and why the tool that is supposed to tell you what needs restarting stays silent about the processes it could not name
• The Life of a DNS Zone — the six stages between a change you made and a change that is over, and why four of the six clocks that decide when it is finished belong to somebody else
• Building a Container Image — the seven stages between the file you wrote and an image somebody else has to run, and why a green build log is a statement about the builder rather than about the image
• Restoring a Linux Server — the seven stages between the archive you kept and a working machine, and why almost everything a restore loses was in the backup all along
• The Life of an Outbound Email — the nine stages between an application calling sendmail and a person deciding they wanted it, and why the one address you set is the only one nothing checks

If you only read one, read the one whose subject has been costing you time. They are deliberately independent, and each links to the others where they meet.