Files, folders, and the command line

A file is one saved thing: a song, a photo, a page of writing. Its name usually ends with a dot and a few letters, like .jpg or .rs. That ending is called the extension. It tells you what kind of thing is inside. Rust code lives in files ending in .rs. The ending really is part of the name: notes.rs and notes.txt can sit side by side as two separate files.

A folder is a container for files. Folders can hold other folders, like boxes packed inside boxes. Some tools say directory instead of folder. It means the same thing.

A path is a file's address. It lists the folders you'd open, one after another, to reach the file. Sam's Windows laptop keeps a song at C:\Users\Sam\Music\song.mp3. Read it left to right: drive C, then the Users folder, then Sam's folder, then Music, and there's song.mp3. Windows puts a backslash (\) between the names. Macs and Linux use a forward slash (/), so on Sam's Mac the same kind of address reads /Users/sam/Music/song.mp3.

An address that starts from the outermost box, like those two (the drive C: on Windows, or the single / on a Mac or Linux), is called absolute. It works from anywhere, like a full postal address with the country on it. A shorter address like rust-course/hello.rs is relative. It's like "second door on the left": it only makes sense once you know where you're standing. The folder you're standing in right now is called the working directory. Two dots, .., mean "the folder one level up from here". A squiggle, ~ (called a tilde), means "my home folder": the folder that belongs to you when you log in.

You'll move around these folders from the command line. That means typing short instructions into a text window, instead of clicking icons. You'll open that window in the second half of this page.

A file is a named block of data stored on disk: a photo, a document, a Rust source file. The end of its name after the last dot, the extension (.rs, .txt, .exe), tells people and programs what kind of content to expect. The extension is part of the name, so notes.rs and notes.txt are two different files. A folder (also called a directory) holds files and other folders. The whole disk forms a tree with one top.

A path is the address of one file or folder: the folders you pass through from some starting point, joined by a separator. Windows uses \ and starts from a drive letter, as in C:\Users\Sam\rust-course\hello.rs. macOS and Linux use / and start from a single top folder written /, as in /Users/sam/rust-course/hello.rs on a Mac and /home/sam/rust-course/hello.rs on Linux. A path that starts at the top of the tree is absolute: it names the same place no matter where you are.

A relative path such as rust-course/hello.rs has no top of its own. It is read starting from the working directory, the folder a program (or a command you type) is currently "in". Three shorthands appear everywhere: . is the working directory itself, .. is the folder that contains it, and ~ is your home folder, the personal folder your account starts in. So the same relative path can name different files depending on the working directory, while an absolute path cannot. The command line means working with all of this by typing commands in a text window rather than using the mouse; the second half of this section opens one.

A terminal is a window where you give your computer instructions by typing instead of clicking. Each instruction is called a command. You type it, press Enter, and the computer does it. Any reply is printed as text right below. Then a short marker called the prompt appears, and the terminal waits for your next command. On Windows the program that reads your commands is called PowerShell, and it runs inside an app called Windows Terminal. A Mac has an app simply called Terminal. Linux desktops have one too, usually with "Terminal" in its name. Details differ. The idea is the same everywhere.

A command reads like a short order: a verb first, then the thing it works on. Take mkdir rust-course: the verb is mkdir (short for "make directory", that is, make a folder) and rust-course is the name of the new folder. The extra words after the verb are called arguments.

A terminal is always standing in one folder, its working directory (the folder that relative addresses start from). When you first open a terminal, it's standing in your home folder. Four commands do nearly everything you'll need at first:

• pwd asks "where am I?" It prints the full address of the folder you're in. The letters stand for "print working directory".
• ls asks "what's in here?" It lists the files and folders.
• mkdir makes a new folder. You stay where you were.
• cd means "change directory". It moves you into another folder. cd .. moves you up one level. cd ~ takes you home.

One surprise: when a command works, it often prints nothing at all. An empty reply usually means success.

A terminal is a window for working with the computer by typing. It runs a shell, a program that reads one line of text you type (a command), runs it, and prints any result; then it shows a prompt and waits for the next line. The default shell is PowerShell on Windows (inside the Windows Terminal app), zsh on macOS, and usually bash on Linux. A command starts with its name; the words after it, separated by spaces, are arguments that say what to act on. In mkdir rust-course, mkdir is the command and rust-course is its one argument.

Four commands cover everything this course needs early on, and they work in all three shells. pwd prints the working directory as an absolute path. ls lists what's in the working directory. mkdir name makes a new folder there, without moving into it. cd path changes the working directory to path, absolute or relative; cd .. moves up one level and cd ~ goes home. A new terminal starts in your home folder. Many commands print nothing when they succeed, so an empty reply is normal.

A command answers you in two ways. The first is the text it prints, which is its output. Error messages count as output too. They're there for a person to read.

The second answer is quieter. When any program finishes, it hands the computer one whole number, called its exit status (people also say exit code). It works like a thumbs-up or thumbs-down that the program gives as it leaves. The rule almost every program follows: 0 means "it worked", and any other number means "something went wrong". Which nonzero number came back can say what went wrong. Each program documents what its own numbers mean.

You don't see the exit status unless you ask for it. On a Mac or Linux, typing echo $? right after a command prints its number. ($? is the shell's name for "the last exit status"; echo just prints it.)

Why have a number at all when there's a message? Because other programs read the number. A tool that builds your project checks for 0 before moving on to the next step. Messages are worded differently everywhere; the number means the same thing every time.

A command reports back in two ways. The first is output: text it prints for you to read, including error messages. The second is its exit status (also called an exit code): a whole number every program hands to the operating system when it ends. By a convention nearly every program follows, 0 means success and any other number means some kind of failure; the program's own documentation says what a particular nonzero value means. The exit status isn't printed, so you ask for it. In zsh and bash, echo $? prints the last command's exit status.

Scripts and build tools branch on the exit status rather than on the output, because the number means the same thing whatever the wording of the message.