Glossary A to Z 📖

anyhow

The go-to crate for error handling in applications: one flexible error type plus .context() to wrap errors in human-readable story. Lesson 20

API

The set of functions or endpoints some code offers for others to call. A library has an API; so does a web service. Foundations 2

Argument

A value you pass into a function when calling it. The function receives it as a parameter. Lesson 4

Arc

Atomic reference counting. Like Rc, but safe to share across threads. Usually paired with a Mutex. Lesson 16

Array

A fixed-size collection of values of the same type, written [1, 2, 3]. For a growable list, use a Vec. Lesson 3

async / await

async marks a function that can pause while it waits; .await marks where. The machinery behind every Rust web service. Lesson 21

Binary (executable)

The compiled, runnable output of your program, as opposed to the source code you wrote. Foundations 2

Binary (number system)

Counting with only 1s and 0s, matching the on/off switches inside a computer. Foundations 1

Bit / Byte

A bit is one on/off switch. A byte is eight of them. Type names like i32 say how many bits a number occupies. Foundations 1

bool

The type holding only true or false. Every comparison produces one. Lesson 3

Borrow

Using a value through a reference without taking ownership of it. Written &value. Lesson 7

Borrow checker

The part of the compiler that enforces the borrowing rules: many readers or one writer, and no reference outliving its data. Lesson 7

Box

The simplest smart pointer: puts a value on the heap with a single owner. Essential for recursive types. Lesson 15

Branch (git)

A parallel timeline of commits, letting you experiment without touching the main line of work. Foundations 3

Bug

Any behavior you did not intend. Hunting one down is debugging. Foundations 5

Cargo

Rust's build tool and project manager: creates projects, compiles, tests, formats, and fetches libraries. Lesson 1

char

A single character, in single quotes: 'A', '🦀'. Lesson 3

Closure

A small unnamed function you can store in a variable, which can capture variables from the surrounding scope. Lesson 14

Clone

Making a real, independent copy of a value, so both the original and the copy stay valid. Lesson 6

Commit

A snapshot of your project at a moment in time, with a message explaining why. Foundations 3

Compiler

The program that translates your source code into machine code. Rust's is rustc. Foundations 1

Concurrency

Doing several things at once, usually with threads. Rust checks it at compile time, hence "fearless". Lesson 16

Constant

A value that can never change, declared with const and named in SCREAMING_SNAKE_CASE. Lesson 2

CPU

The processor: the chef that executes instructions, billions per second. Modern ones have several cores. Foundations 1

Crate

A Rust package. Public ones live on crates.io; over 300,000 of them. Lesson 17

Data race

Two threads touching the same data at once, at least one writing. Impossible in safe Rust. Lesson 16

Dependency

A library your project relies on, listed in Cargo.toml and fetched by Cargo. Foundations 2

derive

An attribute asking the compiler to write a trait implementation for you, like #[derive(Debug)]. Lesson 8

Diff

The line-by-line difference between two versions of a file. Foundations 3

DRY

Don't Repeat Yourself. Extract repeated code into a function so there is one place to fix it. Foundations 4

Enum

A type whose value is exactly one of a fixed set of variants, each able to carry its own data. Lesson 9

Expression

Code that produces a value. The last expression in a function, without a semicolon, is its return value. Lesson 4

f64

The default type for decimal numbers. Lesson 3

FFI

Foreign function interface: calling code written in other languages, usually C, via extern "C" blocks. Every such call is unsafe. Lesson 22

Function

A named, reusable block of instructions, declared with fn. Lesson 4

Future

The value an async fn returns: a description of work that runs only when .awaited. Lazy, like iterators. Lesson 21

Garbage collector

A background process that frees unused memory in some languages. Rust does not need one; ownership handles it. Lesson 6

Generic

A type placeholder like T, letting one piece of code work with many types. Lesson 12

git

The version control system the whole industry uses: snapshots, branches, and history. Foundations 3

GitHub

A website hosting git repositories, for collaboration and as a public portfolio. Foundations 3

Grapheme cluster

One visible symbol that may be several chars glued together, like some emoji. The layer of text above char. Lesson 18

HashMap

A collection mapping keys to values, like a dictionary. Lesson 10

Heap

The flexible region of memory for data whose size can grow, such as String and Vec contents. Lesson 6

i32

The default integer type: whole numbers, positive or negative. Lesson 3

Immutable

Unable to be changed. Rust variables are immutable unless declared mut. Lesson 2

Iterator

Something that hands out items one at a time, and can be chained with adaptors like map and filter. Lesson 14

KISS

Keep It Simple. The boring readable version beats the clever unreadable one. Foundations 4

Lifetime

How long a reference is valid. Written 'a when the compiler needs help connecting inputs to outputs. Lesson 13

Linter

A tool that flags working-but-unidiomatic code. Rust's is cargo clippy. Foundations 4

Machine code

The raw numeric instructions a CPU executes directly. Foundations 1

Macro

Code that writes code at compile time. Marked with !, as in println!. Lesson 1

match

Rust's pattern-matching decision maker. It must be exhaustive: every possible case covered. Lesson 9

Match guard

An extra if bolted onto a match arm: x if x % 2 == 0. The pattern grabs the value, the guard gets a vote. Lesson 19

Memory safety

Freedom from bugs like use-after-free and buffer overflows. Rust guarantees it at compile time. Lesson 6

Merge conflict

When two timelines edit the same line and git asks a human to choose. Routine, not a disaster. Foundations 3

Module

A named grouping of related code, declared with mod. Items are private unless marked pub. Lesson 17

Move

Transferring ownership of a value. The original variable becomes unusable. Lesson 6

mut

The keyword marking a variable or reference as changeable. Lesson 2

Mutex

Mutual exclusion. A lock ensuring only one thread touches shared data at a time. Lesson 16

Open source

Code whose source is public for anyone to read, use, and improve. Rust itself is open source. Foundations 2

Option

The enum for a value that may be absent: Some(value) or None. Rust's replacement for null. Lesson 9

Or-pattern

Matching any of several patterns in one arm: 10 | 20 | 30. Lesson 19

Ownership

Rust's core idea: every value has one owner, and is freed when that owner goes out of scope. Lesson 6

Panic

An unrecoverable error that stops the program immediately with a message. Lesson 11

Path

An address for a file or folder, written with slashes. Foundations 2

Profiling

Measuring where a program actually spends its time instead of guessing. Tools: cargo flamegraph, criterion. Lesson 23

Pull request

A proposed change offered for review before merging. How most open-source contribution happens. Foundations 3

Raw pointer

*const T / *mut T: an address with no safety promises, like C pointers. Creating one is safe; dereferencing needs unsafe. Lesson 22

Rc

Reference counted. Allows several owners of one value in a single thread; freed when the last one goes. Lesson 15

Reference

A way to access a value without owning it, written &value or &mut value. Lesson 7

RefCell

Moves borrow checking from compile time to runtime, allowing mutation through a shared handle. Lesson 15

Release build

cargo build --release: full optimization on. Debug builds can be 1000x slower; never benchmark without this flag. Lesson 23

Repository (repo)

A folder whose history git tracks. Foundations 3

Result

The enum for an operation that may fail: Ok(value) or Err(error). Lesson 11

Runtime

While the program is running, as opposed to compile time. In async Rust the word also means the task scheduler, like tokio. Foundations 2

Scope

The region between braces where a variable exists. Values are dropped when their scope ends. Lesson 6

Semantic versioning

MAJOR.MINOR.PATCH version numbers, promising what a release will break. Foundations 4

Shadowing

Reusing a name with a new let, creating a fresh variable that may even change type. Lesson 2

Slice

A borrowed view into part of a collection or string, like &numbers[1..4]. Lesson 7

Smart pointer

A type that points at data and manages it, such as Box, Rc, and RefCell. Lesson 15

Stack

The fast, fixed-size region of memory holding simple values and function bookkeeping. Lesson 6

String

Owned, growable text stored on the heap. Lesson 10

&str

A borrowed view into text that lives elsewhere. Preferred for function parameters. Lesson 10

Struct

Your own type, bundling related named fields together. Lesson 8

Syntax

The grammar rules of a language. Breaking them produces a syntax error. Foundations 2

Terminal / Shell

The text window where you type commands, and the program that interprets them. Foundations 2

Test

Code that checks your code, marked #[test] and run with cargo test. Lesson 17

thiserror

The go-to crate for error types in libraries: derive Display and conversions from attributes on your error enum. Lesson 20

Thread

An independent stream of execution, letting a program use several CPU cores. Lesson 16

tokio

The standard async runtime: the scheduler that pauses and resumes thousands of tasks on a handful of threads. Lesson 21

Trait

A shared capability that types can implement, like an interface. Lesson 12

Trait bound

A requirement on a generic type, as in T: PartialOrd meaning "any T that can be compared". Lesson 12

Tuple

A fixed bundle of values of possibly different types, like ("Rusty", 42, true). Lesson 3

Type

What kind of thing a value is, determining what you can do with it and how much memory it needs. Lesson 3

unsafe

A fenced block granting exactly five extra powers (raw pointer derefs, unsafe calls, and friends) that you now vouch for. Ownership and types stay checked. Lesson 22

unwrap

Takes the value out of an Option or Result, crashing if there isn't one. Convenient in experiments, risky in real code. Lesson 11

UTF-8

How Rust stores text: one character takes 1 to 4 bytes, so byte count and letter count differ, and you cannot index a string. Lesson 18

Variable

A named place holding a value, created with let. Lesson 2

Vec

A growable list of values of one type. Lesson 10

Version control

Tooling that tracks a project's history over time. In practice, git. Foundations 3

WebAssembly (WASM)

A format letting compiled languages like Rust run inside web browsers. Home

YAGNI

You Aren't Gonna Need It. Build what today needs, not what tomorrow might. Foundations 4

Zero-cost abstraction

High-level code that compiles down to machine code as fast as hand-written low-level code. Generics and iterators are both examples, and Lesson 23 verifies the claim with a stopwatch. Lesson 12 · Lesson 23

? (question mark operator)

Shorthand for error handling: return the error to the caller, or unwrap the success and continue. Lesson 11

No terms match that. Try a shorter word. 🦀