Introduction to variables and basic data types.

Variables

We can provide a _type annotation_ when we declare a variable to be clear about the kind of value that the variable can store.

Some of the basic data types:

- `Int`: integer numbers
- `Double`: floating-point numbers
- `String`: a sequence of characters
- `Bool`: true/false values

Type annotations begin with a colon `:` and end with a type. 

To declare a variable named `artist` and give it the type `String`:

```swift
var artist: String
```

It explicitly specifies the type of a variable to be `String`, so now we can only give `artist` text string values:

```swift
artist = "Daniel Johnston"
```

We can also write the above code in one line:

```swift
var artist: String = "Daniel Johnston"
```

**Note:** Swift is known as a strongly typed language. If you try to give an integer variable a decimal value, you are going to get unexpected results, warnings, or errors.

Type

Often times, we find ourselves needing to insert values into a string. In these cases, we can use _string interpolation_. 

In Swift, to insert a value into a string using string interpolation, we can write the value in parentheses, and write a backslash `\` before the parentheses. 

For example:

```swift
var albums = 17

print("Daniel Johnston made \(albums) studio albums.")
```

It will output:

```
Daniel Johnston made 17 studio albums.
```

Magic! 🔮

String Interpolation

Sometimes the value of our variables need to be adjusted. We know that we can update our variables using arithmetic operators like this:

```swift
var age = 99
age = age + 1
print(age)  // Prints 100
```

We also have the option of using _compound assignment operators_, a shorthand method for modifying the value of variables.

If we wanted to rewrite our previous code using a compound assignment operator (`+=`), our syntax would look like this:

```swift
var age = 99
age += 1
print(age)  // Prints 100
```
Notice that by using a compound assignment operator, we no longer need to reference `age` twice!

Here are some different compound assignment operators we can use:
* `+=` add and assign the sum.
* `-=` subtract and assign the difference.
* `*=` multiply and assign the product.
* `/=` divide and assign the quotient.
* `%=` divide and assign the remainder.

Check out these operators in action as we modify the value of `dollars` five times using compound assignment operators:
```swift
var dollars = 5
dollars += 4   // same as dollars = 5 + 4
print(dollars) // Prints: 9

dollars -= 3   // same as dollars = 9 - 3
print(dollars) // Prints: 6

dollars *= 5   // same as dollars = 6 * 5
print(dollars) // Prints: 30

dollars /= 6   // same as dollars = 30 / 6
print(dollars) // Prints: 5

dollars %= 2   // same as dollars = 5 % 2
print(dollars) // Prints: 1
```
While the value of `dollars` started out as `5`, the value changed every time we used a compound assignment operator; by the end of the program, `dollars` had a value of `1`.

When using compound assignment operators, be sure to include a space before and after the assignment operator `=`; otherwise, we will receive an error.

Compound Assignment Operators

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

Here are some arithmetic operators:

- `+` addition
- `-` subtraction
- `*` multiplication
- `/` division
- `%` modulo (divides and gives the remainder)

For example:

```swift
var score = 0
// score is 0

score = 4 + 2
// it is now 6

score = score - 2
// it is now 4

score = 4 * 2
// it is now 8

score = 4 / 2
// and now 2

score = 5 % 2
// and now 1
```

**Note:** The order of operations can be specified using parentheses. For example, the use of parentheses in `score = 4 * (2 + 1)` sets score equal to `4 * 3` rather than `8 + 1`.

Arithmetic Operators

Suppose we are building a game, and we want to keep track of the player's name, the player’s score that goes from 0 to 10, the player's level, etc. We need some variables! 

Before we can use a variable, we must *declare*, or create, it. 

So to declare a variable called `score` and set it equal to `0`, we need to write:

```swift
var score = 0
```

- `var` is a keyword used to declare variables.
- `score` is the name of the variable.
- `=` is the assignment operator.
- `0` is the value of the variable.

In Swift, a single equal sign `=` means to "assign" values (not compare). In the code above, we are assigning the `score` variable a value of `0`.

So now, we can print out the value of the variable `score`.

```swift
print(score)
```

The output would be:

```
0
```

**Note:** Variable names should be in [camelCase](https://en.wikipedia.org/wiki/Camel_case) format.

Declare a Variable

We've manipulated variables in the last few exercises, but what about variables with values we don't want to change? That's the job for _constants_.

Whereas variables can be reassigned during their lifetime, constants cannot. Once we assign a value to a constant in Swift, it becomes _immutable_. This means that the value stored in it cannot be changed.

In Swift, constants are declared using the `let` keyword:

```swift
let pi = 3.14
```

So why do we use constants? Primarily, constants are used as a safety measure. By using constants, we are making our programs safer by guaranteeing that we only change the values we expect to and thus prevents some potential bugs.

Constants

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.

In this lesson, we will learn about _variables_ and _constants_, as well as some of the basic data types:

- `Int`: integer numbers
- `Double`: floating-point numbers
- `String`: a sequence of characters
- `Bool`: true/false values

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.

Introduction to Variables

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.
- Variables are declared using the `var` keyword.
- Constants are declared using the `let` keyword.
- Swift basic data types include:
  - [`Int`](https://developer.apple.com/documentation/swift/int): integers
  - [`Double`](https://developer.apple.com/documentation/swift/double): floating-point numbers
  - `String`: a sequence of characters
  - [`Bool`](https://developer.apple.com/documentation/swift/bool): true/false
- Single equals sign `=` indicates assignment.
- Arithmetic operators include `+`, `-`, `*`, `/`, `%`.
- Compound assignment operators include `+=`, `-=`, `*=`, `/=`, `%=`.

Review

Now that we've learned about the basics of variables and arithmetic operators, let's write a program!

The mad scientist Kelvin has mastered predicting the weather in his mountain-side meteorology lab.

Recently, Kelvin began publishing his weather forecasts on his website, however, there's a problem: All of his forecasts describe the temperature in Fahrenheit degrees.

Let's convert a temperature from Fahrenheit (°F) to Celsius (°C).

The formula is the following:

```tex
C = (F - 32) / 1.8
```
