Now that we have a URL let's figure out how we can request data

from the Dark Sky API.

To do this we're going to use the data type.

Now before we do anything let me be perfectly honest with you.

What we're about to do is the wrong way of doing things.

Now the code won't be wrong in that it won't work, it certainly will.

But we're going to be committing quite a faults by doing it this way.

The reason I'm going to do it this way is to show you the pitfalls of

this approach and to introduce a couple of crucial topics.

Understanding what makes this approach wrong, for

lack of better word, will make for a much better explanation.

So rather than just telling you, let's walk through it together.

I've also run into this kind of code here and there.

And I want to show you why you shouldn't write it this way,

if you see it on a blog post somewhere.

Now the data type is an important one, and

provides a way to represent data in our code.

And by data, I mean bits and bytes.

Using the data type, which is a struct, we can create an object that helps

us manage and store the data we get back from ranking a network call.

Fetching data from a URL, whether it's pointing to a file on disk or

a resource on a server, and

storing the resulting information in a data object is quite a common task.

And the data type has a convenient initializer, contentsOf, that takes a URL.

The method returns an instance of data with the contents of whatever was at

that URL.

So now that we have a URL, let's create an instance of data using this initializer

to see if we can actually get the data that's at the end of our forecast URL.

So let weatherData = try!, with a forced exclamation,

contentsof, and here we'll say forecasturl.

Now this is optional, so I'm just gonna go ahead and enforce rabbit for now.

This is a throwing method, because as you undoubtedly know with trying to load

a URL, many things can go wrong.

because we're eventually going to get rid of this code,

we're just going to use a force try to avoid error handling logic.

And again, notice we had to force unwrap the URL here as well.

This is because the initializers we used to create the URL, both the string and

string relative to base were fillable initializers.

URL construction can fail for various reasons like passing in illegal countries.

We will go into all this in depth in a future course.

When we run the app,

we are going to automatically make a network call with the URL we've

provided and assign the resulting data object to this constant weather data.

If something goes wrong because we're using a forced try, our code should crash.

So right after we attempt this, let's print the contents of the instance.

Now if this works,

this print statement should show us some information about the instance.

So we'll say print(weatherData), okay?

I'm going to run.

Now once you run your app, the console should pop up with

information about the size of the data object, as you can see here.

Okay, so we didn't crash.

Yay us.

The code works because this forced try that we're using here didn't fail.

While we can't see the contents of this network request, the fact that

the resulting object has a size means we did get some information back.

So we managed to get some information by actually hitting this URL, but

it doesn't look like the data we saw in the Dark Sky documentation earlier,

which I mentioned was that structured format called JSON.

but we do have a way of knowing if our API query was executed correctly.

So we can head over to the Dark Sky console.

If you're on the Dark Sky docks page, click Console at the top and scroll down.

And you can see that if you did this correctly,

you'll see that the number of calls you've made today has gone up.

Mine says two, I read it more than once.

But if you just read it once, it should say once.

Over many times you ran the app and made a call.

If it still says that you have zero total calls today, or this month, or whenever,

that means that you're having some issues with your code, so double check it.

And JSON to go back to it is a common data interchange format that we're going to

work with a lot in any app that talks with the web server.

Before we get into working with it however, let's understand what JSON is and

in particular, what the JSON we're going to be working with looks like.