Level 0 · Foundations

The Programmer's Toolbox 🧰

Programmers seem to speak a private language: terminal, path, dependency, API. It is a small vocabulary, and one lesson is enough to stop nodding along and start actually knowing.

The terminal: talking to the computer in text 💬

Before windows and mice, computers were operated by typing commands. That interface never went away, because for precise work it is faster and more powerful than clicking. The window you type into is the terminal; the program inside it that understands your commands is the shell (macOS and Linux commonly use zsh or bash; Windows has PowerShell).

A command is just a program's name, sometimes with extra words (arguments):

pwd             # "print working directory": where am I?
ls              # list files here (Windows PowerShell: dir works too)
cd projects     # "change directory": move into the projects folder
cd ..           # move UP one level (.. means "parent folder")
mkdir lab       # make a new folder called lab

That is 90% of the terminal skill you need for this entire school. Commands like cargo run follow the same shape: program name (cargo), then arguments (run).

💡 The fear cure The terminal cannot break your computer by you merely looking around with pwd, ls and cd. Explore freely. The few genuinely destructive commands (like rm, remove) you will meet later, clearly labeled, and you will treat them like knives: useful, respected, not feared.

Files, folders, and paths 🗺️

Everything on disk lives in a tree of folders. A path is an address in that tree, written with slashes:

/Users/chris/Projects/hello_rusty/src/main.rs   # absolute: from the root
src/main.rs                                     # relative: from where you are
~/Projects                                      # ~ is shorthand for your home folder

File extensions hint at content: .rs is Rust source, .html a web page, .toml a config file, .md formatted text notes. The computer mostly does not care; humans and tools do.

Editors and IDEs ✍️

Code is plain text, so you could write it in Notepad. Nobody does, because a code editor (VS Code, Zed) understands programming: it colors your code, autocompletes names, and shows errors as you type. An IDE (integrated development environment, like RustRover) is the same idea with even more built in. The magic ingredient for Rust is rust-analyzer, a helper that reads your code as you type and surfaces the compiler's knowledge instantly. The setup guide installs all of this.

Libraries: code you did not have to write 📦

No one builds alone. A library is a bundle of ready-made code you pull into your project: random numbers, JSON parsing, whole game engines. Rust calls them crates, and the public collection at crates.io holds over 300,000 of them. A library your project uses is called a dependency (your code now depends on it), and Cargo fetches and updates them for you.

Related word you will hear constantly: API (application programming interface). It simply means "the set of things some code offers you to call." A library has an API (its public functions). A web service has an API (URLs you can request). When documentation says "the Vec API," it just means "the list of things a Vec can do."

Where the languages fit 🗺️

You will hear language names constantly. A rough map of the neighborhood:

Language	Famous for	Relationship to Rust
Python	Beginner-friendly scripts, data science, AI	Easier to start, much slower to run. Rust often speeds up Python's guts (uv, ruff, Polars).
JavaScript	The language of web browsers	Different arena. Rust reaches the browser through WebAssembly.
C / C++	Operating systems, games, maximum speed	Rust's elders. Same speed class; Rust adds the safety they lack.
Java / C#	Big business software, Android, Unity games	Garbage-collected middle ground: safe but with runtime overhead.
Go	Cloud services, simple and productive	Friendly rival. Simpler than Rust, slower and less strict.

Languages are tools, not sports teams. Learning Rust first gives you the hardest concepts (memory, types, ownership) in their clearest form; every other language feels easy afterward.

Words you can now use correctly 🎓

Source code: the human-readable text you write.
Binary / executable: the compiled, runnable result.
Bug: any behavior you did not intend. Debugging: hunting it down.
Syntax: the grammar rules of a language.
Runtime: while the program is running ("a runtime error" happens then, not at compile time).
Open source: code whose source is public for anyone to read, use, and improve. Rust itself, this site, and most crates are open source.

Exercise 1

Terminal scavenger hunt

Open a terminal. Using only pwd, ls, and cd: find your Desktop folder, list what is on it, then come back to your home folder (cd ~). Narrate your position out loud as you go, like a taxi driver.

Reveal a typical route

pwd            # /Users/you  (home)
ls             # see: Desktop, Documents, Downloads...
cd Desktop
ls             # your desktop clutter, now in text form
cd ~           # home again

Exercise 2

Build your lab bench

Still in the terminal: create a folder called rusty-lab in your home folder. This is where all your course projects will live. Then step inside it and confirm where you are.

Reveal solution

cd ~
mkdir rusty-lab
cd rusty-lab
pwd            # /Users/you/rusty-lab

From now on, when a lesson says "in your project folder," this is your neighborhood.

Exercise 3

Translate the jargon

Rewrite this sentence in plain English: "The crate's API had a breaking change, so our binary hit a runtime bug until we updated the dependency."

Reveal translation

"A library we use changed what it offers in an incompatible way, so our compiled program misbehaved while running until we switched to the library's newer version." Congratulations: you speak programmer now.

← PreviousFoundations 1: How a Computer Thinks Next →Foundations 3: Version Control & Git