--- title: "1.3 Introduction to values and variables" description: "Data, values, RAM, and Rust variables: what let does, and how the compiler tracks every variable's type." url: "https://learnrust.net/chapter-1/values-and-variables/" last_updated: "2026-06-11" --- # 1.3 Introduction to values and variables Programs are instructions, but instructions alone are a vending machine with no snacks. What programs *operate on* is **data**: numbers, text, and everything else a machine can represent. A single piece of data is called a **value**: the number `5`, the number `-6.7`, the character `'H'`, the text `"Hello"`. (Notice the quoting conventions, they matter: single quotes for one character, double quotes for text, no quotes for numbers.) ## Where values live While a program runs, its values are held in the computer's **RAM** (random access memory, usually just **memory**). Picture memory as an enormous row of numbered boxes, each able to hold a small piece of data. When your program needs to remember the number 5, it gets stored into one of those boxes until it's needed. In assembly-era programming (lesson [0.2](https://learnrust.net/chapter-0/introduction-to-programs-and-languages/)), you dealt with those box numbers yourself. In Rust you never do. Instead, you give a value a *name*, and the compiler handles every detail of where it physically lives. ## Variables A named place that stores a value is called a **variable**, and you create one with a `let` statement: ```rust let x = 5; ``` Read it as: "let `x` be 5." This **defines** a variable named `x` and **initializes** it with the value 5. From then on, using `x` anywhere in the function means "the value stored in `x`": ```rust fn main() { let x = 5; println!("x is {x}"); } ``` ``` x is 5 ``` That `{x}` inside the text is a placeholder that gets filled in with the variable's value when the line prints. It's a preview of lesson [1.5](https://learnrust.net/chapter-1/println-and-formatting/), which covers the printing toolkit properly. The name `x` is fine for a math-flavored example and terrible for anything else; real variables get names like `score` or `width`. Naming is its own small art, and lesson [1.8](https://learnrust.net/chapter-1/keywords-and-identifiers/) is devoted to it. > **Key insight** > > A variable is a name for a box in memory, not the value itself. The value 5 also exists, fixed, in your source code (`let x = 5;`), but the *variable* is the box that the 5 gets copied into when the program runs. The same box can hold a different value later, which is exactly where the next lesson picks up. ## Every variable has a type Each value belongs to a **type**: 5 is an integer (a whole number), 6.7 is a floating-point number (a number with a fractional part), `"Hello"` is text. A variable has a type too, fixed at the moment it's defined, which determines what kind of values it can hold. A variable holding an integer will never quietly start holding text. Here's the part that surprises people coming from some other languages: the Rust compiler knows the type of every variable, always, at compile time, before the program ever runs. Usually you don't have to say the type, because the compiler works it out from the value, a trick called **type inference**: ```rust let x = 5; // the compiler infers: x is an integer let y = 6.7; // inferred: a floating-point number ``` You *can* state the type explicitly, with a colon after the name: ```rust let x: i32 = 5; // x is an i32: a 32-bit integer ``` `i32` is the name of Rust's default integer type. The whole cast of types, and the rules for when inference needs your help, are chapter 4's subject (lesson 4.9 in particular); for now, write `let` without types and let the compiler do the bookkeeping. The important idea is that the bookkeeping *happens*: nothing in Rust has a mystery type, ever. ## Quiz time **Question #1** What is data, and what is a value?
Show solution Data is the information a program operates on: numbers, text, and so on. A value is a single piece of data, like `5` or `"Hello"`.
**Question #2** What is a variable?
Show solution A named place in memory that stores a value. The name lets you use the stored value without ever dealing with memory addresses yourself.
**Question #3** What does this statement do, piece by piece: `let width = 80;`
Show solution It defines a new variable named `width` and initializes it with the value `80`. `let` introduces the variable, `width` is its name, and `80` is the value stored into it. The compiler infers its type (an integer).
**Question #4** When does the compiler learn a variable's type: while the program runs, or before?
Show solution Before, at compile time, for every variable in the program, even when you don't write the type yourself (that's type inference).
**Question #5** What's wrong with this statement? ```rust let 5 = x; ```
Show solution It's backwards. `let` puts the name on the left and the value on the right: `let x = 5;`. As written, it tries to use `5` as a name, names can't be numbers, and the program doesn't compile.
A variable whose value never changed wouldn't be very *variable*, though. Changing them is where Rust has opinions, and that's the next lesson. ## Sitemap See the full [sitemap](https://learnrust.net/sitemap.md) for all pages.