Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Variables

Sometimes in our programs, however, we need variables whose values can be modified. 

If you try to reassign a constant variable, this will result in a compiler error. This is where mutable variables come in.

_Mutable variables_ are variables whose values can be modified.

Before you can use a mutable variable you need to declare it. There are two ways, either you declare and assign the variable to a value in one step:

```
5300 ➡️ 🖍🆕 money
```

Here, we are declaring a mutable variable named `money` and assigning it a value of `5300`.


Or you explicitly declare the variable, in which case it won’t have a value initially:

```
🖍🆕 money 🔡
```

- `🖍🆕` means declaring
- `money` is the name of the variable
- `🔡` is the type of the variable

Mutable Variables

So now you might ask, how do we print the value of a constant to the terminal? Oftentimes, we find ourselves needing to print constant values as part of a message in the terminal. In these cases, we can use string interpolation.

_String interpolation_ can be used to construct a string from a mix of constants, variables, and others by including their values inside a string literal.

In Emojicode, to insert a value into a string using string interpolation, we can write the variable inside two `🧲`s and it will print its value.

Suppose we have a constant named `height` with a value of `3000`, and we want to use string interpolation to print out a fun fact:

```
3000 ➡️ height

😀🔤Alex Honnold climbed El Capitan, which is 🧲height🧲 feet, without a rope!🔤❗️
```

It will output:

```bash
Alex Honnold climbed El Capitan, which is 3000 feet, without a rope!
```

Magic!


String Interpolation

Computers are incredible at doing calculations. Now that we have declared variables, let’s use them with arithmetic operators to calculate things!

Emojicode supports arithmetic operators for:

- `➕`: addition
- `➖`: subtraction
- `✖️`: multiplication
- `➗`: division
- `🚮`: modulo (divides and gives the remainder)

For example:

```
4 ➕ 2 ➡️ score1     💭 scores1 is 6

4 ➖ 2 ➡️ score2     💭 scores2 is 2

4 ✖️ 2 ➡️ score3     💭 scores3 is 8

4 ➗ 2 ➡️ score4     💭 scores4 is 2

4 🚮 2 ➡️ score5     💭 scores5 is 0
```

Here, we are doing some arithmetic operations and storing the results in five different constants.


Arithmetic Operations

You made it to the end of the lesson! High five. 🙌

Here is a review of the lesson:

- A variable represents a particular piece of your computer’s memory that has been set aside for you to use to store, retrieve, and manipulate data.
- Emojicode basic data types include:
  - `🔢`: integer numbers
  - `💯`: decimal numbers
  - `🔤`: text strings
  - `👌`: truth values (`👍`/`👎`)
- `➡️` indicates assignment.
- Arithmetic operators include `➕`, `➖`, `✖️`, `➗`, `🚮`.
- Compound assignment operators include `⬅️➕`, `⬅️➖`, `⬅️✖️`, `⬅️➗`, `⬅️🚮`.

Review

In Emojicode, _operator assignment_ provides a short-hand method for modifying the value of variables.

Different compound assignment operators include: 

- `⬅️➕`: addition assignment
- `⬅️➖`: subtraction assignment
- `⬅️✖️`: multiplication assignment
- `⬅️➗`: division assignment
- `⬅️🚮`: modulo assignment

For example:

```
0 ➡️ 🖍🆕i   💭 i is 0

i ⬅️➕ 1     💭 i is now 1
i ⬅️➕ 5     💭 i is now 6
i ⬅️➗ 3     💭 i is now 2
```

The variable `i` is first incremented by one, then by 5, and finally divided by 3.




Operator Assignment

Suppose we are building a game, and we want to keep track of the item names and their in-game prices. We need some variables!

In many cases, you will only assign a variable once, i.e. store a value into it, and then use it without ever changing it. These are the cases where you should use a _constant variable_.

Constant variables are extremely easy to use in Emojicode:

```
3.14 ➡️ pi
```

- `3.14` is the value of the variable.
- `➡️` is the assignment operator.
- `pi` is the name of the variable.

Here, the value on the left-hand side of the `➡️` is stored into the `pi` constant variable.

**Note:** You cannot change a constant variable. If you try to reassign a constant variable, this will result in a compiler error.

Constant Variable

The `"Hello, world!"` program simply writes to the screen. It does not read anything, calculate anything, or allow for user input. That’s no fun!

Real programs tend to produce results based on some input that the user of the program gives, rather than just outputting the same thing every time.

For our computer to produce something meaningful, we first need somewhere in the computer’s memory to store data. That is where variables come in.

A _variable_ is simply a name that represents a particular piece of your computer’s memory that has been set aside for you to store, retrieve, and use data.

Every variable has a _type_, which represents the kind of information you can store inside of it. It tells your compiler how much memory to set aside for the variable, and it defines what you can do with the variable. 

We won't dive into types in Emojicode, but just know that there are a few basic data types:

- `🔢`: integer numbers
- `💯`: decimal numbers
- `🔡`: text strings
- `👌`: truth values (`👍`/`👎`)

In this lesson, we will learn about constants and mutable variables, as well as ways to play with them.