Congratulations, now we know about a fundamental building block of programming,

variables.

As we just discussed, a variable is a container for some data.

And as the name suggests, we can change the contents of the variable.

While this seems like a flexible option and a big advantage, it really isn't.

Let's look at an example.

In real life, let's say I'm out grocery shopping with my son.

I have my shopping basket which has one item in it, some apples.

I tell him to hold on to it but

not to put anything else in there, because kids love to get random things.

A few minutes later I come back and ask for the shopping basket.

But instead of seeing just the apples in there,

there's like a thousand boxes of candy.

Now I, like anyone else, would notice that this basket contains something different

from what I started with.

Like we discussed earlier, computers aren't that smart.

If you assign a different string to the same variable,

it's not smart enough to know that the string changed.

What if we wanted to store values that we don't want to change?

Things like the speed of light, or

the acceleration of the Earth's gravity, or a shopping basket of apples.

We can do this with constants in Swift.

We know that a variable can be thought of as a box with some contents, or

data inside.

A constant is similar, except that when you add data to the box,

we seal it off with a lock and the contents of the box can never change.

We can still see what's inside the box, we just can't reach it and change it anymore.

We can still use it.

Let's look at this in code.

Now, before we write any code,

I'm going to add a comment to keep this playground somewhat organized.

So we'll set a new section here.

We'll say constants, because that's what we're about to learn.

Now at the top, this comment doesn't really mean much, so we'll get rid of it,

and we'll say variables.

Just like we had a special keyword to create a variable,

we have another keyword to create a constant, let.

Now after we use let, the rest of the syntax is exactly the same.

In the code challenge, I asked you to create a variable named language, and

assign the string, Swift.

So over here, let's do that with a constant.

So I'll start with the keyword let, followed by the name of the constant.

So here we're going to say language, and to that we'll assign the string.

Remember we use the assignment operator and

then the actual string, which here is Swift.

So far so good.

The second part of the challenge asked you to then assign the string Objective-C,

to the same variable.

Of course let's try that with a constant.

So remember to change the value of an existing variable,

we just use the name, right?

We didn't use a keyword var.

So we'll do that here as well, so we'll start with language.

And now we'll try to change the value assigned to it by assigning a new string,

Objective-C.

Before you're even done typing, you should see an error.

Now remember that we can click on the red symbol

in the gutter over here to see what the error is.

You might notice that the error symbol isn't that stop sign looking thing

anymore.

But a red circle with a white dot.

This symbol indicates that you have an error,

and that Xcode has a recommendation on how to fix it.

So if we click on it you'll see that the error says,

Cannot assign to value because language is a let constant.

Over here it offers a fix.

It says, Change let two var to make it mutable.

Meaning change it to a variable so that we can change it.

Now, we don't want to do that, so for now let's just get rid of this line of code.

Constants don't seem so different from variables when you write it out, but

under the hood it makes a pretty big difference.

Since we're just starting out,

it's hard to understand why we don't want data to change.

But trust me, we really don't want it to change.

Once we start building apps together, the reasoning will become a lot more apparent.

There is a programmer term for this, and it's worth getting familiar with.

A variable containing a piece of data is known as a mutable type.

So if we do, var str, and we assign the string, Hi, there to it.

Because the variable holds onto a string that we can change at any time,

we call it a mutable string.

In contrast, a constant containing data cannot change, and

is known as an immutable type.

Since the string is a constant,

meaning the value assigned to it is constant, we cannot change this value.

So we call it an immutable string.

A bit of history before we end this topic.

A lot of people ask why the term let is used.

Var seems like a logical choice because it's short for variable, but

what about let?

Let is used in many different programming languages, so the origins are somewhat

murky, but the general consensus is that it stems from mathematical usage.

In math it's quite common to say let x denote some value.

That usage continued on in computer science and

ended up being used in different languages, although with varying meaning.

I also want to take a quick second to talk about Xcode again before we conclude

this video.

When writing code, as we've been doing, every time you hit enter or

go to the next line.

You may have noticed that the playground that you're working in evaluated your code

and then displayed some results, either in the results area here, or

in this area below, that's called the console.

Now if you don't have this area visible, you can click on this icon,

in the second set, it's the middle icon, to make it appear and disappear.

And this isn't how coding typically works.

Code isn't always running all the time, and

results aren't displayed in a results area as you see here.

This is because in Xcode playground, is a specialized

interactive environment that reads, evaluates, and prints our code in a loop.

These types of environments are called REPLs.

R-E-P-L for read, evaluate, print, loop.

Anyway, it's nothing you need to memorize.

But it's important to know that your playing ground is doing

some work on your behalf.

If for some reason while you're working through this code, your code is not

evaluated, because well, Xcode can tend to be baggy, as all software is.

You can hit the play button at the very bottom, so

right here in my window, which is attached to this console bar.

You can hit this play button to get it to manually execute the playground again.

Or worst case, just quit Xcode and start again if things stop working.

Before we round up our discussion on variables and constants,

let's get in a bit more practice.