# Variables and Mutability

We already covered the basics of variables and mutability in Guessing Game, but here's a quick review:

By default, variables are immutable.

`let x = 5;x = 6; // this will result in an error`

However, they can be made mutable.

`let mut x = 5;x = 6; // this is ok!`

# Constants

Constants are immutable (cannot use `mut`), they must be type-annotated, and they must be set to a constant expression, not a function.

`const MAX_POINTS: u32 = 100_000;`

Here's an example of how to do this:

`fn main() {  let mut points = 0;  loop {    println!("{}", points);    if points >= 100 {      break;    }    points = points + 1;  }}`

This works. But it's not really clear. Why are we only going up to 100? Any future developer does not know why I'm doing what I'm doing. So let's improve it with a constant!

`fn main() {  const MAX_POINTS: u32 = 100;  let mut points = 0;  loop {    println!("{}", points);    if points >= MAX_POINTS {      break;    }    points = points + 1;  }}`

This is where Rust gets a little weird and acts differently than you might expect. So while we can't do this:

`let x = 5; // immutablex = x + 1; // no bueno`

We can do this:

`let mut x = 5;x = x + 1;`

But we can also do this!

`let x = 5; // immutable!let x = x + 1; // but this works!`

`let` is essentially creating a new value and Rust allows you to have a value with the same name as a previous value. This really becomes handy when you want to essentially change the variable type. The Rust Book has a great example of this:

For example, say our program asks a user to show how many spaces they want between some text by inputting space characters, but we really want to store that input as a number:

`let spaces = "      ";let spaces = spaces.len();`

If we used `mut` instead, it would result in a compile-time error because these are two different types.