When we tap a button, we want the fact in the middle of the screen to change.

We know how to change our labels text that should be from the attributes inspector

from the story board.

But any changes that need to happen to the UI once our app is running,

like when a button is tapped, need to happen from code.

We need to reference to our label and

code so we are gonna create what's called an IBOutlet.

If we click on our label and look at our attributes inspector again,

which we'll need to open up our utilities pane again to see.

We can see all of these different attributes that we're able to change.

Making an IBOutlet will let us change all of these attributes

right from our Swift file.

Let's close down our attributes inspector again.

So just like before, we're gonna drag and drop this label into our code.

It's best practice to keep all of our IBOutlet connections

up at the top of our class.

Think of it like a stored property.

So let's hold Ctrl, click and drag on our randomFactLabel and

put it at the top of the class right above our viewDidLoad method.

For a connection type, we're making an outlet.

Again, we want a nice descriptive name, so maybe randomFactLabel.

And none of the other options matter right now, so let's hit Connect.

Let's also space out our code just a little bit and there we go.

Now we have a variable named randomFactLabel and it's of type UILabel.

We'll talk more about this UILabel class soon.

Again, the IB means that this is an interface builder outlet and

just like before, we get this nice little bubble that shows us that this

outlet is connected to that highlighted label and interface builder.

Ignore this weak keyword for now.

We needed to be there, but we don't need to know why it's there quite yet.

So now just like with any other variable, we can access it and

it's properties right from our code.

Our randomFactLabel is of type UILabel.

So now, if we come down to our IBAction and

type randomFactLabel which we can see is autocompleting for

us here, so we can just hit tab, and use .notation.

We'll see all of these properties that we can access.

A lot of these are the same ones that you saw in the attributes inspector,

like numberOfLines, shadowColor, text, textColor, and so on.

If you remember,

the attribute that we changed before to alter the labels text was called text.

So, let's go ahead and type text, and

you should see X code start to autocomplete it for you.

The great thing about this predictive text feature

is on top of it saving you from a lot of typing is that you can also see

some information about the property right here from the editor.

So you can see here that our text property

is the current text that is displayed by the label.

We can also see the variables type which in this case is an optional string.

So when we assign a value to the text label,

we can set it to either string or to nil.

Of course, we want our label to have text, so

let's set it to the string, This is a fun fact.

Now let's run our app and see what happens.

When we load up our app, our facts text labels set to this dummy string that

we set in the interface builder.

When we tap on our button though, our text label is set to this is a fun fact.

It's actually cut off right now, but we'll fix that super soon.

This is exactly what we wanted though.

You can see here though,

that every time we tap on our button, our console is printing out Hello World.

And our text is just being set to the same text over and over again.

Soon, we'll add some actual facts into our app and fix our label so it's not cut off.