- Hello, I'm Craig, and I'm a developer.
In this course we're gonna be exploring a term
that you've probably heard quite a bit.
That term is API,
or Application Programming Interface.
In addition to being able to recite what it stands for,
when you complete this course,
you'll be able to discuss what an API does,
you'll understand why they exist,
and you'll be able to list
the many benefits that they provide.
You'll even get some hands on experience
using a few popular web API's
which will give you a taste
of what all this excitement is about.
We'll be starting from the very beginning
so there really isn't too much
I'm gonna be expecting you to know
before starting this course.
I would like to request
that you have a touch of experience with coding,
and a wee bit of knowledge about the web.
If you've written any program at all,
even the typical first program,
you know the one where you write the words hello world?
If you've done that in any programming language,
you'll be pretty much ready for this course.
It will be helpful for you to have a basic understanding
of how the web works with web servers, and browsers,
but don't sweat it.
We'll touch on this too.
Now, if you haven't yet met these requirements,
please check the notes attached to this video
for where to get started with some beginning web,
and programming concepts.
Oh, that reminds me,
you should probably take some time
to get used to your learning environment.
The notes that I just discussed are attached to this video.
I'll also drop more information in that section
to keep you updated on what might've changed
from the time I recorded this.
Now I'll do my best to remind you to look in there
when there's something that I think you just have to see,
but you really should get in the habit
of checking that area out.
There'll be tons of juicy information there.
Now these videos have captions,
so if you feel like you might benefit from having those on,
please use them.
This space is all yours.
If you want me to speak slower,
use the speed controls to slow me down,
and if you know, I'm taking too long of a time,
just speed me up!
I make a pretty good chipmunk,
and last, but certainly not least,
take advantage of the fact
that you are in a video based course.
If you need me to repeat myself,
use the video controls to rewind me.
If you feel like you need a break to let something sink in,
by all means, please pause me.
I'll be right here waiting for you.
I know that I've gotten into some bad video viewing habits
with all the streaming media.
Now, while binging might be a great way to consume
an entire season of your favorite show,
it's not the best way to learn something new.
Education isn't meant to be binged,
and because of this
I'll probably remind you quite a bit to take breaks,
and encourage you to let what you just learned marinate.
Alright, let's get to it.
API, those three little letters
generate quite the buzz, don't they?
Now, first, I'd like to take some time upfront here
to clearly break down what is meant
by Application Programming Interface.
By understanding its purpose, and a touch of its history,
I think you'll start to see its importance,
and begin to understand
why this term keeps popping up in your life.
After we get a good grasp on the what,
and the why of API's,
we'll go, and learn how to explore to existing ones.
We'll get familiar with a handy tool, Postman,
which provides a nice way to interact with web-based APIs.
We'll use that tool to hit an external web API
to send actual text messages,
and get some interesting data back
from a streaming music service API.
After some practice using the APIs,
we'll insert them into a web application.
The application we're going to be building
is a web app called Complimenter.
Our app will allow you to send compliments
to your friends, your families,
and your colleagues over text message,
and then it encourages them to visit your site,
and do the same.
Now I've included the final applications
and together we'll walk through how to use external web APIs
to solve the missing pieces.
We're going to be strictly using APIs in this course.
We won't be writing our own now.
Well now you most likely will end up learning
some best practices in API design,
we won't be covering that specifically.
There are many great courses available
that show the creation thought process,
and I've linked to some of my faves
in the notes attached to this video.
In my opinion,
the best way to start learning about any acronym
is to focus on each individual letter.
For API, I think we should start on the last character,
the I, interface.
Let's talk a bit about interfaces that you've seen already.
Interfaces are all around us.
For instance, this radio here,
it has a familiar interface.
The interface allows me to do things like change the volume,
change the station,
I can turn it off, and on.
I literally have no idea
how anything inside this thing works,
but still the interface allows me to control
the way it works through the options that are exposed.
The magic that is happening
is completely abstracted away from me,
and I'm still in control
of what has been determined, that I, a user, can handle.
Interfaces usually evolve over time,
like an alarm clock radio for example.
It has my familiar volume, and station controls,
and it also adds some new features like changing the time,
and setting the alarm.
I still have no idea how this works implementation-wise,
but the interface is something
that I can understand usually,
and as technology evolves,
and new options come into existence,
they make their way into the new versions of the interface.
Still abstracting away things for us,
but enabling us to be in control of the new features.
Sometimes these physical interfaces get so recognizable
that they even make their way into GUIs.
Did you hear that?
There it is again, gooey, or GUI, Graphical User Interface.
This is my streaming music app on my phone,
and there's my familiar play button
in the User Interface, or UI,
and I know what that play button does when I press it,
but I have no idea how it does it,
and I'm okay with that level of abstraction.
I depend on it even.
What would I do in public transit without music?
Like talk to people?
Hi, how's it going?
Now the developer who wrote this streaming music application
of course understands how the play button works.
She coded the button so that when it gets clicked,
the music starts playing.
Here's the thing though.
Our developer is also working with
quite a few interfaces that are abstracting away
some of the details for her.
For instance, she wrote code
that happens when the button is clicked.
She probably did that using an Event Handler on the button.
What she didn't have to do however,
was write the code that makes the button interact,
and change with the press.
She didn't have to write the code
that makes that familiar clicking noise.
It was already there for her.
Buttons are in fact an interface.
They provide the developer
the means of controlling its interactions
while abstracting away
how that actually works, implementation-wise.
This button is part of the API,
or Application Programming Interface,
that's available from the application framework
that was used to create the app.
Because most apps need buttons,
this interface has been created to help our developer,
or application programmer to use.
Now by implementing the button interface,
our developer was able to make her code run
when the button was clicked.
It's worth noting that the code probably
also uses a media player API
that's provided by the operating system of the device
like Android, or iOS.
This media player API abstracts away needing to understand
the details of how to send audio data to the hardware.
The developer knows that he just want to call
the play method of the media player API,
and I suppose too,
the song isn't stored on the device.
It's being streamed over the network,
so a web based API call
has been made over the internet to get the data.
It's actually APIs all the way down to the ones,
and zeros providing abstractions at many levels.
Let's take a look at
what all these interfaces have in common.
They all define ways for us to interact,
or communicate with an object,
whether that object be physical, or software,
and as a user of the interface,
we don't need to understand the implementation.
We don't need to know how it works.
We just need to know
what we've been allowed to change, or see.
Interfaces abstract away the implementation.
Now, while the UI,
or User Interface is made for the user of the application,
the API is made for the application programmer to use,
and extend in their applications
with the I covered in our API,
let's take a deeper look at the rest of the API acronym.
An API is a contract of sorts,
it defines how it's expected to be used,
and it defines what you can expect to receive by using it.
Think of it as a set of tools
designed for software developers like yourself.
An API is created to help make your life easier
by giving you access to data, and by providing you
with an abstraction of the implementation.
You know, not needing to know
how it's doing whatever it's doing.
They save you from needing to create everything yourself.
When designed well,
they make doing nearly impossible things happen,
in just a few lines of code.
You're probably starting to see why it's important
to get familiar with them, right?
I want to do a quick word of warning here
about some naming issues that you'll probably run into.
These days, The term API is almost always used
as a way to explain web-based APIs.
In fact, it's probably safe to assume
that when you hear API in the wild,
it's most likely that people are talking about
a web based API.
Now we'll explore those here in a few.
However, if we focus on all types of APIs
instead of just the web based subset,
we'll get a better look into
why web-based is are so popular,
so hang tight, we're getting there.
APIs are everywhere in your software journey,
just about everywhere you look.
Your programming language,
whichever one it might be provides many APIs.
Let's take a look at one that's common in all of them.
They all provide some way of working with strings,
you know, like a series of characters.
You want to make your textile upper case?
Just call the API method, and voila,
you could probably create that uppercase string
all by yourself by doing some sort of
low level bit math on each character,
but you don't need to,
because your programming language
has abstracted that away for you,
and provided a handy string API.
It exists because this is a common enough problem
that developers run into,
because these programming language specifications
are just interfaces,
different operating systems
can supply their own implementations
so that the code works properly in their environment.
I think an easy way of picturing this is to think about
how different operating systems like Windows,
or Mac OS maintain their files.
They're totally different,
yet your programming language
provides a single API for working with the file system.
You can write one script,
and it works in either Mac, or Windows.
It's the implementation
that takes care of all the details for you.
Pretty cool, right?
Definitely something to be thankful for.
It makes our life so much easier not having to worry about
what operating system is being used.
The importance of an API
to a language cannot be understated.
There's been some fascinating legal cases
where it's been questioned if the language API itself,
again, not the implementation can be copyrighted.
Check out the notes for more on that.
Along similar lines, there are different web browsers,
you know like Google Chrome, Microsoft Edge,
Safari, Firefox, and Brave.
Now you might not have pondered this before,
but isn't it amazing that you can write code for the web,
and it will work in any of them?
Now this works because there's a set of web APIs
that web browsers all must implement
in order to make that magic happen for you.
We're standing on the shoulders of giants folks.
We really should thank those giants more often.
There are authors,
and maintainers of libraries that package up code,
and solve common problems
so that you don't need to do it yourself.
Like for instance,
do you know how to programmatically
make a photo black and white?
Mean neither, but I can download an important image package
into my application, and suddenly I can.
I just call a method, and boom,
I wish real life skills worked this way.
I'd import dancing so it could be more fun at weddings,
cha cha cha.
Frameworks provide an API
that allow you to extend
what has been provided to make it your own.
Like for example,
most web frameworks provide you with the ability
to add a new route to your web application.
It allows you to write out dynamic data
to a template that you specify,
and you do all of this with just a handful of lines of code.
You don't need to understand how it's doing things,
but you do need to know how to write an implementation
to what the framework is expecting.
In this case, you're using the API,
the contract to write a valid implementation
that meets the requirements.
All of these APIs that we just talked about,
they're local to our code base.
They exist within our code.
We use them to avoid recreating the wheel.
That is to say they assist us in accomplishing tasks
that we need to perform
by abstracting away a ton of work for us.
The stuff that we developers shouldn't be worrying about.
We should be focusing on the business problem at hand,
and that means a big part of your job is figuring out
how to leverage these APIs to your advantage.
Now I think it's an excellent time to take a quick break.
I just gave you a lot to think about,
and I'd like you to take a minute to breathe.
Why don't you jot down some APIs that you've used today,
even if you weren't coding.
I know that you've seen some in action.
If you're having a hard time thinking of some,
I'll give you a hint.
You're watching a video right now inside of a web browser.
When we return,
we'll explore the concept of remote APIs,
ones that aren't executing locally in our code base,
and why that's such a powerful concept.
(calming electronic music)
It took me a while to find this remote control.
It was in the couch.
It's always in the couch.
Anywho, this remote has an interface on it, right?
There's the power button,
and there's a channel changer,
and when I press the volume button,
it sends my request to my device,
and the volume changes as if I turn the volume up
using the interface on the device itself,
and we know why that's important.
I want to remotely control my device.
I don't want to get up from the couch.
There are of course more,
or less lazy reasons as to why you might
want to remotely control objects.
This cute little robot, for instance, has a remote API.
You can send commands to it, and it responds.
It even sends back sensor information.
These traffic signs can change based on an API call.
This drone here,
it's actually remote controlled by an app on my phone.
It's not just physical objects
that benefit from remote APIs.
Oftentimes we don't have space on our local machines
for all the data that's available.
Like for example, have you ever used one of those apps
that helps you figure out what song is planning?
You send up a snippet of a song
you heard playing at a grocery store using your microphone,
and it sends back exactly what the song is.
It's usually Phil Collins.
It turns out both grocery stores,
and yours truly, loves Phil Collins.
You don't have room
for all the songs in the world on your phone,
and with this remote API,
you don't need to have all of them.
It does all the searching, and processing,
and it's surprisingly quick.
How can it possibly do that?
I don't know, but I love the interface.
It's so fast.
There's another benefit of remote APIs, computational power.
Because an API removes the limitations
of your local machine,
you can gain access to seemingly infinite amounts of power.
A good example of that is the AR app of Google Translate.
You can use the camera on your phone,
and in near real time, it's able to translate
directly to your screen, like, instantaneously.
It's using a ton of processing power
to make this magic happen,
and that processing is happening elsewhere.
(speaking foreign language)
It took quite a bit of experimentation,
and some evolution of ideas,
but over time we finally turned
this remote API dream into a reality.
Now, I'm gonna drop some history in the teacher's notes,
but I just want you to know that the struggle
to achieve this concept of remote APIs was very real,
but most of the problem was that
there wasn't a standard that everyone loved.
Things were pretty clunky for awhile
as the ideas were sussed out, but then it happened.
A new architectural style appeared that was clear,
and allowed us developers to interact with
specific resources over the web,
and it quite literally changed everything.
This style rapidly emerged as a winner,
and just about everyone began offering,
and consuming APIs over the internet,
and what I'm talking about here is REST,
or Representational State Transfer.
It was the approach that we needed,
and honestly it's the abstraction
that we developers deserved.
Like we talked about already,
the popularity of REST spreads so rapidly.
It nearly completely overtook the term API.
It's like how we use the word Xerox to mean photocopy,
even though Xerox is just a brand of photocopier.
Xerox does other stuff too, I think.
That's how pervasive REST is.
REST is for sure not the end all be all of remote API's.
There are definitely some limitations,
which we'll discuss here in a bit.
Technology is ever evolving,
and of course there are movements that are still advancing
the concept of the best remote APIs,
some terms you might've even heard, like GraphQL.
More on this in the teacher's notes.
For the rest of this course,
we're going to be doing a deep dive into APIs
that are written using the REST style.
When APIs embrace the style and constraints of REST,
they're said to be RESTful.
If you're feeling like you need a little rest, go ahead,
and pause me before we do a deeper dive into
what it means to be RESTful.
Sorry, that was a bad, and obvious joke,
and as a developer you kind of have to make it,
you don't really have an option,
and because REST sits on top of web technologies,
we should probably do a whirlwind refresher
of how the web works.
(calming electronic music)
It might've been a while since you thought about
how the web works.
There are a smattering of terms
that I'd like to reload into your working memory
before we talk more about how REST uses them.
So let's use the web.
I've got my computer here,
and on it I have an internet browser.
This browser is a web client,
and I'm going to use it to connect to a server.
I'm going to do this
by putting a location in the address bar,
a universal resource locator,
or URL to be exact.
You might also hear this referred to by a superset term URI,
or Universal Resource Identifier.
Now our URL here has a scheme portion,
and this one happens to be HTTP.
HTTP stands for Hypertext Transfer Protocol.
Let's break that down bit.
Let's grab that last part, protocol.
A protocol is also often likened to a contract.
It's a little lower level than an API,
but it's similar in concept.
You can think of it as defining the expectations
of how to communicate.
An example that I find really sticks with me
is if you've ever been to a rally,
and someone does one of those chants where they go,
when I say food,
you say bar, food bar, food bar, here, let's do one.
When I say H-T-T, you say P!
I just realized I might've made you yell pee out loud.
I hope you're in a coffee shop, that'd be awkward.
Anyways, we, you, and I,
we just set up a real quick protocol.
I told you how to respond to my specific request,
you would have been breaking our agreed upon protocol
if you yelled anything else, but P.
So the browser creates an HTTP request for you.
Along with the URI,
it also specifies a particular HTTP verb.
In this case, it's using the GET verb,
which is used to clarify
that this request will only receive data.
That is, it won't be making any changes.
The server receives the request
that was transferred from the client.
There's that second T.
The server then does the work that it needs to do,
and finally it generates the resulting webpage,
and sends back a response to the client,
my browser in this case.
Now, the most important part of that response is the body.
For a webpage that contains the HTML,
or Hypertext Markup Language,
which gives us the remaining parts,
the HT of our acronym.
Hypertext is text that can link to other texts.
In HTML, we perform that linking with anchor tags.
So with that response,
the browser renders the page.
When one of those links are clicked,
they kick off a brand new HTTP GET request,
and the process repeats itself over, and over.
In between those clicks though the protocol is done.
We made the request, we got the response.
HTTP as it was originally designed is a Stateless protocol.
Once that request receives a response,
it's all done.
If you want to keep some sort of state,
your client will have to manage that itself,
and set it up with each new requests.
Check the notes for more on this.
There are more HTTP verbs,
also known as request methods, besides GET.
Most common scenario you see is when you encounter a form
that is used to take information from you,
typically you'll see the verb post
used to explain that you are submitting,
or posting data to the server.
Okay, so our protocol that's used to transfer this hypertext
is admittedly a little more complex
than our rally chant was.
There's quite a bit of important information
that's included in both the request and the response.
You've probably seen query string parameters, and URLs.
You know, the stuff after the question mark?
This is one way to pass information about the request.
Another common way this information
is passed around is through specific key,
and value pairs, called headers.
Both requests, and responses have headers,
and they're used to help further communicate
what is wanted as well as what has been sent back.
Now, some of the popular request headers
allow you to specify information
about the content that you'd expect back like the language,
or the type of content.
You can also state you only want a page
if it has changed since a certain time.
This technique allows for caching
which is a powerful concept.
Why get the whole page
if you already have it in your local cache?
You can embed authentication information
in each request using a header.
This way you are essentially
keeping your client logged in across requests.
The response also contains headers.
A super important one is the status code.
This lets you know what happened on the server side,
and it can convey things like missing documents.
I'm sure you've seen the old 404 error.
The page has been moved,
or hopefully everything is A, 200 OK.
It can also explain the content type,
how large the data return is,
and many more things.
Okay, got it?
Feeling good about that little whirlwind tour?
Remember, feel free to make me repeat myself
if that was way too much.
I totally get it.
That was a lot of information.
It's important to have
a basic understanding of these things,
because REST sits on top of them.
It uses the concepts that were introduced
with the web to expose resources
that can be accessed, and manipulated.
Let's take a look at how
the RESTful approach takes advantage of the web,
and it's tooling for your benefit, and profit.
REST stands for Representational State Transfer.
APIs that meet the REST architectural style constraints
are considered to be RESTful.
A typical way to teach about RESTful API's
is to cover the constraints that define it all up front.
I don't know about you, but personally I find
approaching learning that way pretty overwhelming,
especially from the beginning.
I mean we haven't even looked at an API yet,
and on top of that,
most of the REST APIs
that you use will meet all of these constraints.
So here's the thing,
I promise that we'll go over all the constraints,
but let's do it on our own time.
Like don't learn them all, right this instant.
We can even make it a fun journey
like a RESTful constraint scavenger hunt,
complete with prizes.
Here are the guiding architectural constraints
required for an API to be considered RESTful.
We'll check them off when we discuss them,
and then we'll loop back once more at the end, and review.
Got to collect them all.
Let's get started talking about
how REST APIs sit on top of web technology,
like a little hat.
Much like the web,
the client makes a request to a server.
The client in this case
is typically going to be your program,
and you'll probably be using some sort of library
to create the request to the server.
The protocol used is, you guessed it,
HTTP, and it's Stateless.
The server won't remember
anything about the particular client.
If you want to maintain state like your login details,
you must send it with each, and every request,
and you'll do this using headers,
and just like that,
we've talked about two of our REST constraints,
Client-Server Architecture, and Stateless.
You got two knocked off already.
You're on a roll now.
We should probably talk about
what that request was requesting, right?
Well, it most certainly was requesting about a resource.
A resource is a little abstract,
and that's intentional.
It's the R in the URL, or URI,
we use the term resource to reference an object,
which also happens to be pretty abstract, right?
This is because we can use resources
to describe just about anything that we build.
For instance, let's imagine an ebook store website.
On the homepage, maybe there's a list,
or a collection of new books.
Each of these books is a resource,
and we click into that to take a closer look
at the book resource,
and we see a link to the author,
which is also a resource.
We click into the Author Resource,
and we see a collection of all the other books
that they've written.
Maybe we even see a group of fans.
Again, another collection,
and each of those fans are a resource.
Clicking into a fan resource,
we can see the collection
of their favorite authors, and books.
Everything is a resource.
Let's change gears.
How about an image sharing application on our phone?
So we have user resources.
Those users post photos,
which are resources,
and the photos can be loved.
So there's like lover resource.
Maybe there's an album that could be created,
and there's an album resource
that contains photo resources,
and albums have a collection of contributor resources.
Turns out almost everything we ever want to build
can be expressed in terms of resources, and collections.
Most of what we want our applications
to be able to do to their resources can be expressed through
the unfortunate sounding acronym CRUD, and that stands for
Creating, Reading, Updating, and Deleting.
Now as a user of the ebook site,
all we did was a bunch of reading,
no pun intended.
Actually I did intend that one.
We were reading, right?
Just getting the information to display
like we retrieved the author page.
We made a read request for that page.
The web browser used a GET request
to that specific author page.
Now the RESTful API follows the same logic.
Your program sends a GET request to a URI.
Then the survey response with data,
and of course all the HTTP headers
that you've come to know, and love,
and the body is typically represented these days as JSON,
Now, JSON provides a great way to structure,
and nest your data.
Every programming language that I can think of
provide some means of turning a JSON string
into a native object.
Content type is typically something that you can specify
on your request if JSON isn't your thing.
Now, if you recall, there are other HTTP verbs available.
These verbs are used in REST APIs
to clearly state the intention of your request.
Want to add an author?
Post to the /authors,
and send the data that you want to update
in the body of your request.
These fields will be defined for you somewhere.
Want to remove an author?
Send a delete to that specific author.
Updates typically support the patch verb,
and you'll see we're able to represent CRUD,
the Create, Read, Update, and Delete using HTTP methods.
Pretty cool, right?
What this means is that you can interact
with any application out there
that's exposed their REST API.
You could grab data remotely automate tasks,
and even smush services together.
This is called a mashup, and here's the thing,
there are tons of APIs available
just about anything you could imagine,
and if they're truly RESTful,
they'll all feel pretty much the same.
You can build anything.
There are services that allow you
to do incredible things with a few simple API calls.
So now the question becomes,
what are you gonna build?
Why don't you take a quick break,
and when you come back,
let's explore a RESTful API together?
We'll take a peek at how to use
the music streaming service, Spotify,
and they're excellent RESTful API.
(calming electronic music)
You have some new found understanding
of how web-based APIs work.
I'll walked you quickly through some imaginary REST APIs,
and now I'm thinking it's time
that we get a little more specific.
Why don't we go exploring together?
Now, some of these REST APIs allow you to give it a try
from the comfort of your very own web browser,
and one of my personal favorites that allows for exploration
is the streaming music service Spotify.
So here I am at Spotify.com,
and a quick word of warning,
this for sure is going to look different.
By the time you get here,
there are teams of people
working on the site to make it better,
and you're gonna have the benefit of a better website
than I have right this instant.
So just a reminder,
you should check the notes attached to this video
for any breaking changes,
and if you don't have a Spotify account yet, don't sweat it.
As you can see, it's free,
and that same user that you can create,
you can end up using for development purposes.
So let's assume that I didn't know that Spotify had an API.
Now, what I usually do is I look around.
So typically most sites store the nerdy stuff
down here in the footer.
There we go.
Developers, that's what we're looking for.
It's a community of developers.
That's us, let's do it.
Wow, I love a site that treats me well,
even as a developer.
This is really nice, right?
So you can do a ton of stuff since I was last here,
let's take a look here from the front.
So audio analysis,
wow, you can learn about danceability,
maybe I will be able to install that skill after all.
Oh, cool, audio playback.
So you can kind of nice,
you can embed a player right in there.
You can put a player into your application,
an SDK here, that stands for Software Development Kit,
and we'll look at one of those here in a bit,
but basically what it does is it gives you an API
that wraps around other APIs,
and it will feel native to your programming language.
Cool, and then let's take a look here at recommendations.
It will give you specific recommendations.
Awesome, this is great.
Target danceability, I'm gonna be able to dance,
it's doing a GET to one of their end points.
Awesome, this looks good.
So let's take a look up at the top here.
Let's go ahead,
and discover that's what we're trying to do.
We're trying to discover
what we're going to do with this API.
So let's click into here,
and this will give us some ideas of what we can do.
Real apps that integrate audio features in.
This is awesome.
I love when sites do this.
I find that it's a great way to get inspiration
if you don't yet have an idea of how you might use the API.
You can see how other people have used it.
Cool, so this is the audio analysis that we had seen,
a quick dashboard of audio features of songs,
and there's that danceability again.
Here's playback, so you can get a player.
This is super neat,
and these are apps that use them.
iPhone app, a listening room, Runkeeper.
So you can see here, this is for iOS,
and this is for Android based phones.
So iOS being like Mac based products,
and this is Android based products,
and this is widgets.
I'm not exactly sure what that is.
I'm assuming that's the HTML widgets that we had seen,
and that's cool, right?
Because it's a web based API,
all we need to do is to connect to it over HTTP.
So any of these devices can connect to it.
Alright, let's keep going.
So we've got recommendations.
I always need music recommendations.
Search, oh, that's nice.
That actually feels like a good place to get started, right?
And like if we went,
and we searched for different things,
so there's six degrees of Kanye West,
I guess a lot of people are connected to him.
Find other artists that are like the artists you like,
this is great.
Why don't you say,
we look at some of the documentation for search?
So I'm going to click this, read the docs.
Let's read the docs.
Oh, nice, now you might not see this,
but there's a brand new web API reference in beta,
which means it's not quite ready for everybody,
but it's ready for people to try.
I'm gonna go look at that.
You might actually be there,
and be out of the beta period by the time you see this.
Okay, so let's take a look,
and let's see about this Search API.
Let's see, Search API.
So let's go ahead.
Let's click into there.
As you use more, and more APIs,
you'll get super familiar
with reference documentation like this.
This is explaining the contract
of what we need to do to use this API.
So you'll see here that there's different parts.
So this is what the request is
that we're gonna be sending,
and it's saying here that this is a header,
and this says whether,
or not things are required,
and this indeed is required.
So this is authorization here.
There's a header that's required
in the request for authorization.
The authorization means it knows what you're allowed to do,
or authorized to do.
Spotify, and many other APS use the concept access tokens.
So then, so that's a header,
that's the header that's required,
and so here we see this query parameter, right?
So query parameters,
and you'll see that this one's required this queue.
So this is the search query,
the keywords, right?
So, and here's an example of what that is,
and this is showing you that it needs to be URL encoded.
There's some more notes on this here in the bit.
So no, we have queue is required,
and also type is required,
and type is like album, artist, playlist,
like the type of resource
that is available in Spotify's API,
and if we keep scrolling down, there are more,
there's more optional query parameters that are available.
Really help you specify your search,
very rich API they have,
and then it shows you this response.
So this is what's gonna come back.
So you'll see that you'll get a header,
and the status code, very important.
We'll say 200 okay.
If it's good on success rate.
On success I'll say 200 okay,
and the response body contains an array.
So like a list of artists, objects, or album, artist,
whatever it was the type you were looking for,
and it's going to be in JSON format,
And so you'll see when there's an error,
there'll be an error code,
and the body will have the error message,
and then there's some more notes here,
and these are really thorough.
This is great.
So in code spaces, that's what we saw.
We saw that %20.
It's making sure that you can't use a space,
otherwise it breaks the URL.
So this is how you do that.
You'll see there's lots of different information here.
Yeah, you can use asterix,
and show you in all sorts of ways to do fun queries.
Let's go ahead, and try this out in the web console.
It's pretty slick.
So what this does is it lets us search for an item,
and it's showing us how it's doing.
It's doing a GET,
and it's does have some authentication required.
So we will need to build something here,
but you'll see over here it's showing what it's doing.
It's doing a GET to this URL,
and this is code here that will actually run,
and you'll see as we change the fields here.
So I'm gonna change this
to a very popular artist around my house, Lizzo,
and you'll see that it updated over here.
It updated my query, and the type is set to artist already.
So that's fine,
and we have this OAuth Token that we need to get.
So we need to get this token.
So again, this is the,
what are they authorized to do?
So we're going to go,
and choose Get Token,
and it's telling us that this specific endpoint
doesn't require any specific scopes.
So these are scopes that you can do.
So when you build this token,
it's saying for using this key,
these are the things that the people are able to do,
and we don't need to do anything specific for this.
So let's just go ahead,
and let's not check any of these.
We don't need to modify a private playlist,
we don't need to do that.
So we're going to do Request Token,
and here's it's gonna ask us to log into Spotify,
and if you have Spotify, go ahead, and log in,
and if you don't remember,
it's free, you can totally just come in here,
and do a sign up.
And we can put in our emails here.
So I'm going to put in mine,
and here's a little trick,
if you don't know this yet,
I'm gonna put in API course.
Let's do API course like firstname.lastname@example.org.
My email address is CraigsDennis@gmail.com,
but if you put a little plus here,
you can kind of categorize things your own.
So just a little trick,
and that way if you're worried about emails coming in,
you'll know that they're coming in from that address.
I'm gonna do the password to my luggage,
which is one, two, three, four, five, just kidding.
What should we call you?
I love it when you call me big papa.
Alright, so my date of birth is November 19th,
and I was born in the wonderful year of 2000, just kidding.
This is awesome.
I love this Spotify.
Thank you for being inclusive, inclusivity matters.
I'm gonna choose Male.
I don't want to share my registration data,
and I am not a robot.
I think I'm not a robot.
Identify the crosswalks.
What is that?
Alright, so there's one that's definitely a cross walk.
That's a crosswalk.
I mean, I could walk across the street here, I could.
Alright, I passed.
I'm not a robot.
I'm gonna click Sign Up.
Here we go.
I'm gonna save that password.
What if I turn on sync?
All logged in as Big Papa.
Here we go.
So I'm going to click Agree.
I'm going to pop back to the page,
and you'll see now this is filled out.
Now one thing I do want to point out here
is that my token here, my key is on the screen,
and if a hacker were to pause my screen,
and copy that down,
they could essentially do things to my account on my behalf,
but I of course know that,
and I'm gonna delete this token later.
Remember this is like leaving your car keys
on your driver's seat.
You probably don't do that.
So treat these keys the same,
and keep them safe, and with you.
So I could just copy this whole command,
and paste that into my terminal,
and it would work.
We'll do that in a bit,
but what I want to show you first is that you can do this,
Try It button here,
and what happens is what comes back is this beautiful JSON.
So you'll see that what's being returned here is as artists,
and it's an object that has the search that we built,
and then here is this items,
and you'll see that it's an array,
because there could be multiple artists named Lizzo,
and I guess looks like maybe there is.
Yeah, it looks like there's actually
another artist named Lizzo, popularity 88,
and what's this Lizzo's popularity?
Her genre is Escape Room?
Man, I feel old.
One thing we can do is we can look,
and see if there's these external images
so you can kind of take a look,
and see if it's them.
I'm going to click Go To Here,
and we'll see what happens, and there she is.
Lizzo is on all the time at our house.
Once my daughter has figured out that
Alexa could play music,
they're like play Lizzo, Alexa, play Lizzo.
Alexa, by the way is a Voice User Interface, right?
There's the I again.
So I'm gonna get back to our tab.
And we will go now,
and we see here that she has an ID,
because we're in this artist, right?
So we see here that she has this ID.
I'm gonna go ahead, I'm going to copy this,
and you also see that there's another API call here
that we can do.
There's this HREF that will get her specifically, right?
So there's the /artist,
and there's /herID.
So if we call that it would get information about her.
Again, I'm gonna make sure that I copied her ID here.
I'm gonna scroll down a little bit more.
Think there's the other Lizzo.
I think there was a thing where we can look at the page.
Yeah, here we go.
So here's external URLs,
and you'll see this as an API.
This is the actual Spotify page itself stuff.
So if I'm gonna do this, and I'm gonna right click.
I'm gonna say, go to.
This is Lizzo's actual page,
and this is how it's displayed, right?
As a web page on Spotify.
If you scroll down here,
we'll see that there's this popular,
there's her popular songs,
Good As Hell, great stuff.
If you don't know her, use this link, learn her.
I happened to know that we can get a list
similar to these popular songs using the API.
So let's go back to our reference.
Okay, so we're back here in our reference.
Let's look at the artist API.
So we're gonna click on Artists,
and again, I'm going to go into the beta,
whether they be a reference might be what's live for you,
and I'm gonna click into the Artists API over here.
I'm gonna scroll down a little bit.
So there's get an artist, get an artist's albums,
and what else do we have?
Get an artist's top tracks.
This is exactly what I wanted to do.
Okay, so again, here's the docs about that.
I'm gonna try this out in the web console.
Okay, so get an artist's top tracks.
It's gonna do a GET,
and this is the end point.
So we're gonna just kind of,
it needs that ID, right?
So we're gonna put that ID in there.
It's coming defaulted with somebody.
So I'm gonna go ahead, and paste Lizzo's in there.
Okay, and the country is US,
and you'll see that again, it's changing.
So see how the her IDs here, country's US,
and we're gonna pass our private keys along.
I'm gonna click Try It.
Alright, so now we've got a list of tracks,
and each one of these tracks has what album it showed up on.
Okay, so again, this'll be in the same list,
their top tracks as we saw on that page,
which is super neat, right?
There's the, because I love you song,
and let's keep going a little bit.
You'll see how the URI's here,
they use a different style URI
with the colons to separate,
but it's Spotify artist, and then the ID.
And we'll see here that there's this preview URL,
which you could actually just go ahead, and open,
and it will start playing this song.
Pretty cool, right?
You can get access to all of Spotify's music library,
and you can build tools that extend their platform.
I highly recommend that you go,
and take a look at what people have built using these APIs.
Did you notice how fast those results came back?
How could it do that search so quick?
Oh, wait a second, does it even need to?
The results don't change all the time.
It's not like Lizzo is dropping a new song every minute.
Though, I wish she would.
Those results are definitely cacheable.
Ding, ding, ding,
Casheability is also available on the client,
and we'll get to that here in a bit,
but this is a great example of a Layered System.
I'm almost positive that Spotify has set up things
so that returns that same JSON
from its own server side caching mechanism.
It's not on every request.
Now as a user of the API,
I don't know how it's doing that,
and frankly I don't care.
I want it to be available
and fast when I hit that specific URL,
and as Lizzo might ask, baby, how you feeling?
I'm feeling good as hell.
That was fast.
Spotify is just one REST API.
There are tons, and tons of services out there.
There are even services that exist only as APIs.
Let's go ahead, and take a quick break.
I'd love for you to take some time,
and think about what you might be able to build
with the Spotify API.
For instance, while I was using the API,
I had this idea pop up.
I'm often at festivals,
and I'm having a hard time
figuring out which band I should go see.
There's so many.
I love to have an app suggest me
which of the bands that are playing
that I would most likely enjoy
based on my listening cabinets.
I'm pretty sure you could do that
just by using the Spotify API,
and a list of the bands performing.
If you end up building this app,
please share it with me.
What other interests do you have
that provide an API that you can use?
Check the notes for more ideas
after you come back from your break,
let's dive a little deeper,
and make use of an API using our own tools.
See you soon.
No, really take a quick break.
Seriously, it'll do you good.
(calming electronic music)
While I realized that exploring an API
on a website is informative.
It might not feel like you're actually using that API.
I think the next logical step in exploring
is actually making that request yourself from your computer,
not from a website.
Let's use a different API,
this time let's use Twilio.
Twilio is a company that loves APIs.
In fact, that's most of what the company is.
It's a company for developers
that helps abstract away telephone communications,
well actually all kinds of communication channels.
It lets you bring communications into your applications.
It allows you to make, and receive calls, and text messages,
and a whole slew of other things.
I need to be a little upfront with you here.
I love Twilio.
I mean, I love it so much
I even applied for a job with them,
and I got it, but even if I didn't,
I would still show you how cool their APIs are.
I mean with a single command you can send a text message.
I remember when I first did that,
I was like, wow.
That level of abstraction is amazing.
How does that work with all the different cell carriers,
the varying standards, and networks?
I have no idea, and I don't need to,
that's the beauty of this API.
Let's get started.
So I'm here at Twilio.com, and again a word of warning,
this will most likely look different
as Twilio is constantly making improvements.
So please check the notes for any changes to this flow.
So first things first, let's sign up.
We'll be able to use a free trial account
for the rest of this course.
Let's sign up with my information.
I am Greg Dennis, and again I'm gonna use that trick.
So I'm gonna say CraigsDennis+ let's say API course,
in case I've already done that one @gmail.com,
and I will set my password too,
and I am going to accept the terms, and services,
because I've read that.
And I'm gonna start my free trial.
Save my password.
There we go, and it's sent an email to my Gmail.
I will go check that real quick.
There we go.
I've got a email, and I am going to click on that link.
Let's do this.
And we'll paste it here.
Verify my account, and I am logged in.
Alright, so I'm gonna put in my phone number,
which is (503) 461-5537,
and this phone number you provide will be used
for authentication for the Twilio Console.
Somebody might contact me of free onboarding.
That sounds great.
I'll check that.
I'll click Verify.
So in trial mode
we can only communicate with numbers that we verified.
So do you write code?
I write code, I write Python code.
My goal today I'm gonna use it in a student,
or hackathon project for sure.
I'm gonna send, or receive SMS.
SMS is a Short Message Service,
which is text messages.
We're gonna send text message.
So the way Twilio works is you buy an actual phone number.
Well, let's do it.
So we'll get this trial number here.
This number got automatically selected.
It's fine by me.
(201) 584-8089, and I'm gonna choose it.
Let's say Choose This Number,
and just like that the number is mine,
and I can program it,
and we'll do more with that later.
So I'm gonna click Done.
So there's some notes here, right?
You can only send messages,
and make calls to verify numbers.
That's how our Twilio trial account works right?
Notice also, we have $15,
which is more than enough money
to do anything we're gonna do in here,
and it's also says that messages,
and calls include a note about this coming from
Twilio trial account.
Okay, that's fine.
What do you say we send a text message?
Let's do it.
So the way that things work is over here,
there's a little menu, and we have different things.
As you can see, there's a bunch of stuff available.
We're gonna choose this very first one here,
this programmable SMS short message service.
I am also going to pin that to the dock
so that I can get to it easier.
So it'll always be there, okay?
So, you'll see here, it's pinned.
Well on this page, I'm gonna choose, Get Started.
Let's do it.
Now, this step allows us to explore the API
like we saw on the Spotify site.
You'll see as I change things here
so let's change this body to say, ahoy,
you'll see that it changes the code that's over here.
Fun note here,
ahoy was the first word ever spoken over the phone.
So ahoy is kinda like hello world of phones.
So I'm gonna go ahead, and click Make Request,
and I got the text.
Of course it's prefixed with sent from your Twilio number,
but whoa, right, I just sent a text by pressing a button.
Let's take this a step further.
I'm gonna copy this code,
and actually first before I do that,
I'm gonna check this show your Auth Token.
Just like Spotify, Twilio uses Auth Tokens,
and their private keys,
but I trust you, and also I'm gonna delete this later.
I see you hackers.
So now if I come over here,
and I click this Copy icon here,
it will be in my clipboard.
Now I'm running on a Mac,
so I'm gonna open up my terminal and I'm going to paste.
So see how this is the URL
that we are going to post to, right?
We're going to post,
because we're gonna be creating a new message.
Notice here, this is my account SID, or String Identifier,
and because we have a JSON here,
this .JSON, that tells the Twilio API to return JSON,
and we use form a URL, and coding here.
This is what this data URL,
and coding is, and this is the two.
We're gonna send it to my phone number,
and it's gonna be from our Twilio number,
and the body's gonna be, ahoy.
So I can come in here,
and I can change this code, right?
So I can, and instead of ahoy,
I'm gonna make it say, ahoy from terminal,
and this dash U here
is setting up the authentication of the account SID,
and this is my Auth Token.
So when I go ahead, and press Enter,
we'll get some information back,
and it tells me that it was successful.
It will give an error if it didn't,
I got my text message.
So this command is sending a post, which is great,
but I can also use GET to receive
the messages that have been sent.
So kind of like a sent log.
So what I'm gonna do is I'm gonna use the up arrow,
and get the information back.
I'm gonna change to GET,
and then I'm gonna get rid of the rest of these lines,
which I'm gonna do with GET in here,
and do Control+K on the Mac.
Look in the notes for how to do this in Windows.
So we're gonna say all of the messages
that were sent to this,
and if I go press Enter, that didn't work,
because I left the trail
at the end, have to press up again.
So I'm gonna get rid of this trailing slash,
because that means like continue on to the next line.
So here we go.
Now, I need to have my account SID.
So let's do that again.
Let's go press up a couple of times.
So I forgot that I need,
we're gonna need to keep our information there.
So let's just go ahead.
I'm gonna get rid of all of these lines.
So again, that's Control+K, Control+K,
and this is dash U,
and we're doing a GET to this account,
and we're saying all of the messages
that were ever sent from this account,
let's take a look at that,
and we're doing a GET, so we're not doing a post.
So we're gonna show a list.
There we go.
So again, you could format this,
or make it prettier,
but for now though, let's keep exploring some more tools.
Awesome job getting that running on your local machine.
It feels pretty good, doesn't it?
What a cool skill you now have.
You can send a text message from your machine
with just a single command.
Now, believe me,
this is just the tip of the iceberg of what you can do.
There are so many more Twilio APIs available,
but for now let's take things a step deeper.
I don't know about you,
but I'm a little clumsy
when it comes to long commands on the terminal
like we just did with Curl.
When exploring API's,
I really like to lean on a tool called Postman,
and I think you'll enjoy it too.
Why don't you take a quick break,
and then we'll check out Postman?
(calming electronic music)
Postman is a wonderful feature rich tool
that I use all the time to explore new APIs.
It started out as a Chrome Extension,
but recently became a full fledged application.
It's super handy.
I love how it can help you organize your learning,
and I think it's an excellent exploratory tool too.
Let's dive in.
Postman can be downloaded at GetPostman.com.
Go ahead and pause me while you get an installed.
This right here.
Download the app, and I'll wait,
and when you're done un-pause me,
Okay, so here it is.
I've got an installed too,
and when it comes up it will have this Create New,
and typically when I end up using this tool,
I'm working with a specific API,
and what I'd like to do is to create a collection
to keep all of the requests that I make grouped together.
So I'm gonna choose Collection here.
So Create New Collection.
Let's recreate those calls that we made
to the Twilio API using Curl.
So let's do that right here.
So we'll call this
the collection name is gonna be Twilio,
and then I'm just gonna click Create.
Down here there's a little window thing,
a little bar over here.
You can see that you've got your collections over here.
So we have a new one here called Twilio
and in here you'll see that we can add requests.
So I'm going to go ahead, and click Add Requests.
So let's build that message log.
Remember that was the GET that we did over in the terminal.
So I'll name this request,
that request name is message log,
and I like to make a description here
about what's going on here.
So this is gonna be all messages sent from my account.
That's what we were looking at, right?
That's what that message log was,
and if I'm taking notes,
usually what I do is I drop a link to the documentation
about what the resources that I'm looking at.
That way I have a quick way to get back to it to look at it.
So one way to do that is just go find the documentation.
So if we just do Twilio message resource doc,
that's what I had there before.
So that's gonna find the resource for the messages,
and a resource reference.
And the way that the code here works here
is very similar to like we saw on Spotify,
the different things that are available.
There's the create message resource,
and each one of these kind of has its own little heading,
and there's some code over here that we can switch.
So I want to look for list all messages.
That's what we want with the message list, right?
So I've got this example,
and I'm gonna grab the URL,
and I'm gonna come back over to Postman,
and just drop it in there,
and a Postman uses,
here, this is marked down.
So I'm gonna use brackets, and say Twilio documentation,
and then if I put parens, I can paste the link there,
and that will make a link inside of my notes.
Let's scroll down a little bit here.
Twilio offers a ton of different API,
so I could break this down even further
with this thing called a folder.
So let's open this up actually,
and let's make a new folder here,
because you know, there's so many different APIs,
we might be playing
with a bunch of different things.
So what I like to do is put these in folders.
So let's make a folder.
We'll make the folder called SMS.
Okay, and we're gonna add that to the SMS folder.
Okay, so what does the saying is
we're gonna make this new request.
We're gonna create a new folder called a SMS,
and when we click Save,
we'll see that here underneath Twilio we have this SMS now,
and there's our message log as it were.
And so what's happened here is it's created a tab
for our new requests that we've made,
and you'll notice that there's a little twisty here,
and there's a tab,
and there's the link to my documentation,
which is handy as you'll see as we're going through this.
So let's go grab that URL that we had.
I'm gonna go back to my terminal,
and I'm gonna press the up arrow,
and I have that there.
If you don't have this go ahead,
and look in the notes,
and I've got a copy for you.
So I'm gonna copy that.
I'm gonna come here,
I'm gonna put the request in here.
One thing to notice over here is
there's this dropdown that says GET,
and we can send different types of,
here's the different verbs, right,
that we can send across HTTP verbs, a bunch of them,
and we're gonna leave it at GET right now,
because that's what we're gonna do.
We're gonna get the messages,
and I think we're all set.
So let's go ahead, and click Send,
and oh we got an error.
You'll see that we got back a 401 Unauthorized.
So if I mouse over it,
I see more information, which is nice,
and if I scroll down here a little bit,
here's the error message that came back from Twilio.
It says your account SID,
or Auth Token was incorrect,
and oh yeah, we didn't even pass them.
So you can add that authorization to your request
by this little tab here.
So next up param, this is authorizations,
and here we'll say type inherit Auth from parent.
Oh, that's actually a great idea.
We're gonna be using the same account SID,
and Auth Token anyways,
so we should just use it from the parent, right?
So I'm gonna open up my Twilio collection, which is here.
So if the screen ever gets closed,
this little guy here pops out.
So I'm gonna go to my Twilio collection,
and right click on the buttons here,
and I'm gonna choose Edit.
Here we go, and we'll come over here to authorization.
So what this does is all requests,
will share this if they have, you know,
inherit from parents.
So we'll get this authorization.
It's used for every request in the collection,
which is what we want,
and we're gonna change the type to be a basic Auth,
which is what we're using there.
So we'll click Basic Auth, and look at this.
We were gonna put our super secret information here,
but it's saying heads up.
These parameters hold sensitive data
to keep this data secure
while working in a collaborative environment.
We recommend using variables.
I don't know about you,
but whenever I see a security warnings,
I like to follow that.
So let's follow that.
So let's, there's variables here.
So it says, learn more about variables.
If there's also this Variables tab up here, right?
So let's click into Variables.
Okay, so what these do is we create a new name,
and it will have a value,
and people can set on their own machine there,
these own values.
So this is a good way
of not accidentally sharing out your keys.
So the things that we want is
we want to have the account SID,
which is a string identifier.
So Twilio account SID,
and the way these these work is,
there's this initial value.
This is what people will see when they come in.
So we want them to fill out their own.
So we'll say your account SID.
So if anybody is using this,
you're gonna share it.
That's what they'd see,
and we'll get the current value.
So that's over in my Twilio console.
So if I go to Twilio/console,
which is the main page, once you log in,
you'll see here that I have my account SID,
here it is, and then there's a little copy button.
So I'm gonna copy my account SID,
and we will paste that,
and the current value is my account SID,
and then we'll do another one.
We need the Auth Token.
We'll say Twilio Auth Token
it will say your Auth Token,
and again, what we want is this Auth Token.
I'm gonna copy that.
And paste that here.
and I'm gonna click Update.
So I'm gonna go again again, and choose Edit,
and I'm gonna go to Authorization,
and now that we have it,
Postman allows you to use those variables
wherever you want to,
and you can replace them by using a curly brace.
Sometimes those are called mustaches.
If you look at that sideways.
So we'll do Twilio account SID, right,
so it's double mustaches, right?
So mustache, mustache, and then it does that.
So mustache, oops, and for the password,
we'll do Show Password
just so we can see that we're doing it right.
We'll do mustache, mustache Twilio, Auth Token,
that's how this works.
So there we go.
So that is going to set the authorization
for all of the collections to these variables
that are local to our machine.
There we go.
So we'll click Okay.
Update, and now let's go ahead.
I'm gonna close this window here,
this little nothing, and I'm gonna click Send.
Okay, so we've got the authorization headers in place.
We'll click send.
There we go, beautiful.
Much nicer formatted.
See here we got our messages,
we've got an array of messages that came back,
and we have ahoy from terminal,
and we should have another one.
Now, there's nice URIs that we could go look at other things
like feedback that came
or the media that's attached to it,
and here you'll see the original that we did that was ahoy,
and you'll see that the cost of it was 0.07 of a cent.
Now that we've got all of our foundations set up,
we've got our collection,
and we've got our variable setup,
let's go ahead,
and let's make it so that we can send a post from this
right after a quick break.
(calming electronic music)
So we've got our message logs all set up in Postman.
So now let's use it to create a post request.
Now since we want to use that same authorization
that we use in the message log,
we should put it in the collection, and folder.
So let's go back over here.
Again, if this is closed,
you click this little like I hit to pop this out.
So we're gonna add a new request
inside of the Twilio SMS here,
and we're gonna make Add Request,
and the request name is going to be Create a Message.
So we'll say creates a text message,
and then I'll see if I have the Twilio docs up still.
I don't, so we'll have again,
we'll search Twilio message.
There it is filling it out for me.
Message, resource reference.
And over here on the left nav
we can see that there's different bits.
We want this create a message resource.
This is definitely what we want.
You see there's the URL.
So we will copy that,
and bring that back over to our Postman.
It will say Twilio Documentation.
And it's in the SMS folder,
because that's where I started it from.
Let's bring this all the way up,
and we'll say save to SMS.
That's the folder.
Awesome, so we have this Create a Message.
So let's see in order to create a message,
remember we're gonna do a post,
and it's that same URL
that we were using from the get message log.
So see how there's two tabs here?
So I'm gonna switch back over to my GET.
Oh, look at this.
We see here that the account SID is in there,
and we don't necessarily want to put
our accounts SID there for each one.
We want anybody who uses this to be able to use it.
So let's change that to use a Twilio account SID.
So that way we'll use the variable that we've created right?
So that's gonna replace that automatically here,
and then you can see what it is by mousing over it,
and now let's click Send,
and make sure that we got it.
Cool, now this is a usable URL for anybody
if we were ever to share this.
I'll show you how to do that here in a second.
So we'll paste this here,
and when we're creating a message,
we're gonna need to
send some additional information, right?
So if we click over here,
and we click on this body tab,
so we're gonna send some values,
and in the Curl command we sent that
using a form URL encoded.
So let's do that.
What were those values though?
Oh, you know, I should pop over to the documentation.
I am sure glad that I made that link so I can click here.
Open that up.
Cool, so we definitely need a two.
That's right, we need a two from,
so you may also need to pass a body,
or a media URL with a messages content.
Media URL, does that mean I can send pictures?
Cool, we should do that, shouldn't we?
Cool, so there is two,
and there's from, body, and media URL.
Now I'm gonna set this to the Curl and because you see
these different programming languages here,
we're gonna set this to Curl.
So it's in the right format here.
So there's media URL,
and the two in the front half capital F's there.
So that's the format that we want.
So we'll say two,
and that's my number that we want to send this to.
So this 1-503-461-5537.
So let's add a body.
So we'll do body again,
need to make sure that it's checked.
So body, and we'll say sent from Postman,
and you can actually send,
in these messages, you can send emojis,
which who wants a text manager without emojis?
My frequent used one is the mussel taco.
Frowny love rocket, sent from Postman, awesome,
and why don't we send a media URL?
We saw that there in the notes.
So we'll say media URL, and the URL,
we can send any sort of a GIF, or Jif, or a whatever,
however, whatever you can send here whenever you want.
I'm gonna copy,
and paste one of my faves that we can send.
Feel free to use your own image.
I've left some fun suggestions on the notes,
if you want to copy.
Giphy is a great site to find those.
So let's see, we get to body media.
Now, we need from, we need from,
so that's our Twilio number.
So I'm gonna click in here,
and I'm gonna say from actually,
this is something where,
this is my personal number,
so why don't we add a variable for that?
So I'm gonna flip back over here
to the Twilio variables.
So we'll come back to edit,
come in here to variables,
and we'll add a new one for let's call it Twilio number,
and I'll say your Twilio number,
and our Twilio number.
Let's look at that, and it's in the console.
So Twilio/console, here's our trial number,
that's what we want.
Copy, and paste that,
and we'll paste that here.
Here we go, say Update,
and so the from value we can use Twilio number.
Alright, this is feeling good to me.
Here it goes, nothing.
We're gonna click Send, and boom,
201 created awesome,
and I just got my text message, and there's my GIF.
Pretty cool, right?
So creating an MMS,
or multi messaging service message is a lot more difficult
than this if you were to attempt to do that by scratch,
but the abstractions in place, right?
So it was pretty much seamless for us.
Now you'll notice here that the message says
maybe you won't notice the status here says queued,
but if we go, and we look at our message log,
and we run this thing again,
we can see that they're sent for Postman, there's our emoji.
And here's some more information,
and if we scroll down a little bit more,
we'll see these sub resource URIs
and now we can see this media that was sent along.
So let's go ahead, and I'm gonna just click this link,
and watch what it does.
It's gonna make a new GET requests.
Now there's a bit of a problem,
because this GET request is outside of our collection.
So typically when I need to do something like this,
there's a little hack that you can do
so I can get the authentication information.
So let's just click Save,
and I just call it,
you can just call it that if you want to,
and then I'm just gonna call it temp,
because we'll delete it when we're done here.
So we'll just call it Temp.
Say that to SMS, and when we run this,
we'll see that we got back the list of medias,
and because you can send multiple, right?
You can send multiple pictures in a,
and we'll see here that there is an official one,
and see how it is accounts, and then messages,
and then media there.
There's sub resources.
So I'm gonna go ahead, and I'm gonna click on that.
And if we wanted to, we could run this request,
and it would be,
it would show information about the media,
but if you actually remove this .JSON,
it will show the form of whatever the media was.
So we'll make this request,
and watch what happens.
Let's see, we got back my GIF that I sent.
And with a request of this size,
we probably don't want to be making that request again
if we don't need to.
So this sounds like the job for client side caching.
Well let's see if our API supports caching tricks.
So what I'm gonna do is I'm gonna expect the headers
that are on this response.
Nice, so it has this last modified header here,
which is a good sign that it does support caching.
So let's go ahead, let's copy this value.
So I'm gonna copy this date here into the clipboard,
and if I go up to where my request was made,
if I come into headers here,
I can add a new header, and I'm gonna say if,
and you'll see that Postman is doing a really good job
of showing you what's available.
So if it's been modified since that time,
because this is basically what your client would do, right?
It says, if this thing has been modified since this time,
then show me anyone, otherwise don't.
So that's what this does.
So I go in, and go ahead, and I'm gonna go ahead,
and click Send,
and you'll see that my API returned this time not modified.
So our API supports caching,
which ding, ding, ding,
means we covered another part of RESTful API constraints
using standard HTTP caching mechanisms
like last modified, and etags,
a RESTful API should support caching.
It's up to you to maintain the cache on your client,
and decorate your request,
but this can come in really handy
to avoid making unneeded requests.
Awesome, so let's make sure that we've got these saved.
Do you see these little orange dots here?
Means that they haven't been saved.
So I'm gonna click on it,
and click Command+S, or Control+S,
and I don't really care about the temp,
and I don't really care about this one.
That was just kind of exploring.
So let's take a look here.
We have this temp, we can choose, and say Delete,
and we'll delete it from temp,
and now he has this, have our message,
and our create message.
One more quick thing before we wrap up.
I wanted to show you,
you can actually generate code from this.
So if you click in here, you can see,
here's an example of generating a code snippet.
It's gonna actually run through the code,
and set up everything that you need to run this code.
Now there are things called helper libraries
that will do this,
and Twilio has one,
and we'll look at that here in a second,
but this is pretty slick, right?
Really, really powerful,
and you just copy it to the clipboard, and boom.
Pretty powerful, huh?
Awesome job diving into Postman.
It's a super powerful tool,
and it keeps getting better every day.
There are so many features that we didn't even cover.
We barely scratched the surface.
Check the notes for where to learn more.
We saw how to organize our requests together
into collections as well as share common,
and secure values by using variables.
We learned how to add different values to your requests,
both in form, values, and headers,
and we also saw how to navigate
through various sub resources by clicking URIs.
We even saw how to create
actual runnable code from your request.
While we were in the Twilio documentation,
you might have noticed
the code examples on the screen.
On that page, it's possible to tab between
various language implementations, and solutions.
Many products offer what is known as an SDK,
or software development kit,
or Helper Library that allows you to interact
with their product in your native language.
As you can see,
it abstracts away the REST API completely.
Let's take a look at the Twilio Helper Library next.
Before that though,
just a quick reminder
to make sure that you check out the notes on this video.
There's a link to a repository of built out collections
that are ready for you to use.
There are lots of great API's to practice with.
Postman and Curl are both great tools for accessing,
and exploring APIs.
However, when it comes time,
most likely you're gonna need to write some code.
As we saw in Postman, you can actually generate code.
All programming languages
come with some sort of way of making requests,
and as you know, HTTP requests are all we really need
to interact with REST APIs.
Now writing that sort of code is totally fine,
but you'll find out that you end up writing
a lot of what is known as boilerplate code.
Now, by boilerplate, I mean code that is repetitive,
and almost always the same just with a few tweaks.
Many products, and services have created a solution
to help you avoid this problem.
They're often called helper libraries, or SDKs,
Software Development Kits.
They'll be specific to your programming language.
These libraries help to make your code
more concise, and legible.
They usually also provide
additional documentation for your editor,
which I find super handy.
Let's go check out some of these helper libraries.
In order to do that,
I'd like to make sure that you have both Node,
and Python installed under computer.
I've put installation instructions in the notes.
Let's get started with Node.
So I'm gonna open up the terminal on my Mac,
and I'm gonna make a directory called scratch,
and I'm gonna change into that directory,
and I'm gonna CDN to that directory,
and I'm gonna open my editor in this directory here.
So let's say code.
I'm using Visual Studio Code.
So we're gonna open up Visual Studio Code,
and over here in our directory,
I'm gonna add a new file,
and I'm gonna just call it explore.js.
Alright, now what I'm gonna do is
I'm gonna install the library
in Node land that is called NPM.
So I'll open up a little terminal
here in Visual Studio Code,
and I'm gonna run NPM, install Twilio.
And that's gonna go out,
and it's gonna get the library so that I can use it,
and I can use it like so now,
now I can say const Twilio Goals require Twilio.
And then we're gonna initialize it.
So we'll say const client equals new Twilio,
and as you can see,
it takes an account SID,
and an Auth Token,
and I have those available for us here.
So here's my account SID, I'm gonna copy that,
and we will make the Auth Token after that.
Alright, so we'll put that, awesome.
Now can you think of anything wrong with doing that
with putting my account SID and Auth Token there?
Well, right now this is just sitting on my machine,
but if I were to upload, or share this with anyone,
my credentials are sitting right there
waiting for anyone to steal.
Typical solution here is to use environment variables,
and we'll do that when we build our application,
but this is just a friendly reminder.
Be careful with the keys.
What we're gonna go over here
might very well be overwhelming,
but it will make sense someday if you stick with it.
I promise, oh, I've added notes,
but really don't let this stress you out.
The reason why I'm talking about this behavior is,
It's asynchronous, and it relies on
a concept called promises.
So the way the promises work
is that you set up handlers
for when your method call actually completes.
So to get our message log, we use this method.
There's a method called,
so we do client.messages.list,
and what that method returns
is an object that is called a promise.
It's a promise of a future value.
The future value in this case will be our messages.
So promises have an important method on them,
and it's called then.
So I'm gonna go ahead, and chain on that message.
I'll say .then, and this method should be given a function
that accepts of value.
So I'm gonna pass it a function.
you can use what are known as fat arrow functions.
So what I'll do is I'll put the name of the value,
and the value here is messages, right?
Because this is what I'm expecting to be returned,
and then I'm gonna put a fat arrow,
which is an equal sign of greater than,
and then I'm gonna put the function body.
So let's just log out the most recent message.
Okay, so we'll do a console.log,
and I'm gonna use back ticks
so that we can get a string interpolation,
and I want it to be the first one in the array.
So we're gonna say
the most recent message is dollar sign,
curly brace messages, zero, because it's in array.body,
and that is a long line in,
this happens quite a bit.
So typically what we do is
when we do this chain,
is we press Enter here,
and we put that on its own line,
still pretty long still off the screen,
and if I ask this to format with prayer,
let's see what it does.
There we go.
Let's see, you know,
it's done a pretty good job of getting things close.
So, and then again,
just to show you that this is running asynchronously,
I'm gonna below making this call, right?
So this is, looks like it's after that calls made.
Well it is after that call is made is just,
that call's gonna be asynchronous.
I'm gonna say gathering your message log.
So let's go over it real quick.
What's going on here
is that we are getting a hold of the client,
and we're setting up a new client
so that all requests made
against this client are authenticated, right?
So that's our account SID, and our Auth Token.
And then we're gonna use the client,
we're gonna use the messages out there,
we're gonna do a list, and that list
is an asynchronous method.
Now while this has been abstracting away,
we know what this is doing.
It's making that same GET request that we did in Postman,
and in Curl,
and we know that it will return a JSON response,
but because this is asynchronous,
immediately it's going to move on to the next line.
It's gonna say gathering your message log,
and when that call to list returns,
it's gonna run this function,
and it's gonna pass in the return value
of that response to here.
Now you should note the return value here
is an actual object.
It's not a JSON response.
That sneaky little Helper Library of ours
has also abstracted that away for us.
It took that HTTP response,
which has a body of JSON in it
automatically turned it into an object for us,
and you can see that here,
it's an array of objects, right?
So that's at the zeroth, okay, so let's run it.
So I'll do clear down here,
and we're gonna say Node explore.js.
So we should see gathering, or message log,
and then the most recent message, fingers crossed.
Here we go.
Now, one thing that we should make sure to do here
is to capture any errors
that might have happened asynchronously,
right now if an error happens,
it'll be swallowed.
Well actually, let me demonstrate what that means.
This bites me all the time,
and I don't want it to bite you.
Let's say that you accidentally
trimmed the last character off here, the seven of mine.
Let's take the last one off here.
So I'm just gonna do that.
So it's an invalid SID,
and I'm gonna save, and I'm gonna run it,
and it's gonna say gathering your message log,
and then it's just gonna end out no error, no nothing,
but the results never came back.
So what we need to do is
we need to catch any errors that might occur.
Every promise has a method named catch,
and what might not be clear here is that
this then here, that's returning.
This is actually also a promise.
So I can just chain on here.
So I can say .catch,
and I'm gonna catch an error,
and again, fat arrow function,
and we'll just log that error.
So I'll say console.error.E-R-R.
Okay, so now we've got, it's gonna chain,
and if anything happens, it's gonna send the error.
So let's try that again.
Let's see what happens now with our catch in place.
It tells us that it wasn't found,
because that's wrong, right?
This is probably a good time to remind you
if that was way too much information that you can,
and you probably should scrub the video back,
and watch me do it again.
I guarantee that you'll catch some stuff
you missed the first time,
and at the very least,
you'll spot a dad joke that I made
at the very beginning of this video.
I had said, this will make sense eventually.
I'm kind of obligated to make that joke,
and if that doesn't make sense yet, that's also okay.
Check the teacher's notes for more information on promises.
Let's change gears,
and take a look at the Python version
of the Helper Library right after a quick break.
I know I need one.
See you soon.
(calming electronic music)
We just took a look at
and now let's take the Python Helper Library for a spin.
Now, if you don't have Python installed, pause me,
and check the teacher's notes for instructions.
In my terminal, from my scratch directory,
I'm gonna create a new Python directory.
So mkdir Python, change into that,
and while we're here, let's just check,
and make sure that we have the right version of Python.
So I'm running Python 3.7.3.
As long as this first three here is a three, and not a two,
we're good to go.
Python uses the concept of virtual environments.
These allow you to install packages
local to this application.
So let's do that just to be safe.
So, that's done with the dash -m,
and then venv, for Virtual Environment,
and I usually just call that .venv.
So that will create a directory
called .venv that is right there,
and here we go,
and what happens is now I'm on a Mac,
so this might look a little bit different on Windows.
If you do .venv,
there is a directory called bin activate,
and I'm gonna source that file.
I think that's a .bat file on Windows.
Check the notes,
and you'll see now that I am activated.
So I've got this .venv here.
I'm gonna go ahead, and open up my editor.
So I'll do code doc, and here we are.
There you can see my .venv directory,
and I'm gonna add an explore.py.
Alright, and I want to install the Twilio Helper Library.
So I'll do a Control+Tab,
and you'll see that my editor actually went ahead,
and ran that argument for me.
So I'd already, I'm activated here, which is good,
because I want to install a package here using PIP,
which stands for the Acute Recursive Acronym
of PIP installs of packages.
So that's PIP install, and again, Twilio.
Cool, so it's installed, and we can start using it.
So I'm gonna go up here,
and we'll say from Twilio.REST import Client,
and we'll make a new client,
and again, it can be instantiated using
so here it's given us this nice information
that's available about the API.
So we'll put a,
I'll put in here again,
this is our account SID,
and boy, it really wants to show us that account SID,
and Auth Token.
So let's get that.
So again, account SID, and Auth Token.
Let's get these on some of the new lines by themselves.
Again, really bad practice to leave your keys out like this.
We'll fix that in a bit.
Now let's print out the call log real quick
just to show off the similarities,
and differences between the libraries.
So the Python version is synchronous, right?
So we can say, so we can just iterate
through those lists, and messages.
So we can say for message in client.messages.list,
and we will say print the message.body.
Alright, let's see what that looks like.
So we will do Python Explore.py
and I didn't save it.
So that's an important part, Python Explore.py,
and there we go.
Sent from Postman,
Ahoy from terminal.
So awesome, So let's go ahead,
and we'll comment that out for now,
because we're gonna do something else.
So those are commented out,
and let's write some code to send a new one.
So we'll say message equals client.messages.create,
and in here we are going to pass our variables.
So we're gonna send this to me,
or to you in this case, (503)461-5537.
It's my number,
and the from,
now you'll notice that from is a key word in Python, right?
So see like from Twilio?
So what's nice is the Python library has made it
from underscore here.
It helps for the reserved words.
So my number, my Twilio number, what was that?
Here it is.
That's my Twilio number.
and let's do a body, and we'll say body, hello from Python.
Yeah, let's go ahead, and let's print things out.
So Python has a nice little thing called F strings
which will allow you to print variables that are in scope.
So we'll say if created a new message,
and let's just show the message SID
to make sure that we got it,
and we can just do msg.sid.
Hey, so it starts with an F,
and it uses the mustaches around this for message.sid.
Let's go ahead, and create this one.
So we will run Python Explore,
and this should send a message, and it did,
and again, I want you to see
we are abstracting away the fact that
we're posting to the messages sub resource under my account.
It's just magically happening,
because we've logged this client in pretty cool, right?
The other thing that this abstraction gives us is
we have instance variables that represent our resources.
Now, it might not have been clear up here
when I looped over these objects,
but they're actual objects.
It's not just data.
They actually have methods,
and I can call the delete method on this message,
and it will get deleted.
In fact, that's not a bad idea.
We've been doing a lot of test exploratory messages.
Let's just delete them, okay?
So what I'm gonna do is I'm gonna come up here,
and I am going to uncomment this code
and I'm gonna comment out our creation message code,
and let's make this an F string here.
So we'll say deleting message body.
Here we are.
We're gonna say message.delete.
Now before we run this,
I want you to make sure
that you understand that we're gonna delete
all the messages in your account
if you've been using a live account,
and have things that you want to save,
I highly recommend not running this.
Okay, you've been warned.
So here we go.
I'm gonna update this.
There we go.
So we've just deleted all of our messages.
So if we come, and try to run it again,
you'll see there's no messages to loop over.
We've done it, clean slate.
It's like the nothing never was.
Pretty cool, right?
That Helper Library was able to
abstract away the HTTP delete call,
and it used the information that it had available
in its object to make the call itself.
You see how the helper libraries are similar
yet match the development workflow,
and style of each language?
This is one of the key benefits
of helper libraries in general.
They abstract the way the HTTP client connection
of the REST API boilerplate.
They also behave as you expect them to behave.
It feels natural.
The way that we were able to delete from the resource itself
helps to unlock another REST API constraint
scavenger hunt item, and that is uniform design.
Now this constraint has four sub sections,
one of which is what we just discussed.
Resource manipulation through representations,
because there was enough information included,
it was clear how to modify,
and delete this resource.
Another sub section in here is
resource identification in requests.
Those are the URLs that are included,
because of the URIs are included,
we know that we can get,
and manipulate specific resources.
Uniform use of the HTTP verbs is pretty powerful.
We just wrote some scripts
that make use of helper libraries.
These libraries are super handy for automation based tasks,
or batch scripting,
making a whole bunch of calls at once.
When we're talking about this,
we should cover another common tool
for talking to external API's,
and that is the C-L-I,
or Command Line Interface.
There's that I again.
Command Line Interfaces can be used to make API calls
from an executable on your machine.
More, and more these are showing up
for all sorts of tools that require authentication,
and do a bunch of different services.
This concept is popular amongst cloud providers
where setting something up needs to be done quickly
from the command line.
Check the notes for more.
Another commonplace where you'll use helper libraries
is from within applications that you're building.
Let's get to the final unit of this course,
and implement an external API
into existing web applications.
You've got this.
By now, I hope you're starting to see
that external APIs allow you
to add pretty incredible features to your applications.
Want to send a Slack message
when someone fills out feedback on your website?
There's an API for that.
Want to change the color
of your lights in your house
when your favorite sports ball team scores?
There's an API for your team,
and for your lights if you want it.
Want to send yourself a text message
10 minutes before your bus shows up?
APIs are there too.
Heck, do you want to make a Furby dance?
It's got an API.
They're everywhere, and give you lots of power.
We've seen how to use them from the command line,
and we've seen them used in scripts,
but now let's take a look at
embedding them in a web application.
I've gone ahead,
and build the starts of web application for us to play with.
Now, one thing I know I don't do enough of
is to compliment my friends, and family, and even coworkers.
Sometimes the web can be so negative.
So I was thinking,
what if we made a web app that did the opposite of that?
So the way it works is you fill out a web form
for who you're complimenting along with their mobile number.
You say why they're great,
and they get a text message telling them how great they are,
and an encouragement to do the same,
and of course they will, and when they come,
and see the messages that have been sent by everyone else,
they'll be pleasantly surprised.
Pretty sure we have a viral success here.
So if there happened to be any venture capitalists watching,
that's my phone number there.
Now if building,
and deploying a website
feels a little too much for your current skillset,
have no fear,
I've created a couple of repositories of code
that we'll be using.
We're gonna use a fun,
approachable tool called Glitch to host our websites.
The website is basically functioning
minus our API that we're gonna add.
If you haven't used Glitch before,
it's a collaborative community built around learning.
You take existing projects,
and you remix them.
It has an online editor.
So I want you to head over to Glitch.com,
and create a user for yourself
if you haven't done so already.
After you're all set,
let's get to adding our API to the application.
First, let's take a look
at the Python based web application.
We're gonna be using a web framework called Flask.
Flask provides an API that lets you extend the framework
to create your application.
This example application
is going to be doing server side rendering.
This means that the pages
will only be created on the server side.
Any change, or navigation will require a full page reload.
In the notes,
I've included a link to the repository
where I've got our starter code.
So go ahead, and copy that.
Now I'm gonna open up Glitch.com,
and I'm gonna choose New Project.
From here I'm gonna choose Clone From Git Repo.
In here, I'm gonna paste what I pulled out,
and I'm gonna do, this is the one for Flask,
so I make sure that's the one that says Flask.
I'm gonna click Okay.
I've been having a couple of problems with this.
Sometimes this will just sit here,
and say loading project.
If it does, just try that same thing a couple of times.
Let's see what happens here.
Sorta times out a little bit.
I guess it's safe to say that Glitch is Glitching.
Now, that's not fair.
There must be some sort of bug that's happening right now.
I'm experiencing it.
I'm wanting to record this
just in case you run into it to just do it a couple times
if that happens.
I do want to point out
that it is pretty amazing what Glitch is doing.
It's pulling us over.
It's sending up a whole new environment for us
in a web server that can run,
and I actually have one that's up, and running.
I did the same thing where I made a new project,
and you'll notice I'm not even signed in,
so that's fine.
They let you not even sign in,
and create these things.
So here we are.
Down here under tools,
there's a thing called logs that you can open up,
and it will show you what happened.
This is what happened though.
It's set up our web server here,
and you'll see that the server's actually running,
and if you come up here,
you can, and click on Show,
and the sunglasses here.
Your future's so bright, you've got to wear shades.
So you can click View in a New Window,
and you'll see that the application is up, and running,
which is awesome, right?
And this URL here, this is all yours,
you can use it to do whatever.
So the application itself, it's pretty simple.
It's just a page with a form, and this section in here,
provides messages when they eventually come in,
but as of right now, we don't have any,
because we just erased all those, right?
But as of right now,
we don't have any way to send text messages.
We don't yet have the Twilio Helper Library
installed in this application.
So let's go back over here.
So these are the files that are available over here.
So you can see here is app.py,
and there's some settings that you can do up here.
You can come in here,
you can actually change the name of this
to be whatever you want to be.
So I'm gonna call this Complimenter
and we'll say compliment your friends.
Cool, and this is another nice thing you can do
is you can change the theme.
I'll put it on dark theme.
I don't know when you're watching this,
but this should be okay, both in light, and dark.
So there you go.
You can also delete this
if it's not something that you want,
if you ended up creating something.
So this app.py, this is our program.
Flask works by creating an object called app.
So you do this Flask name,
and it creates this thing called app,
and then what you can do is
you can put different routes in here.
So for instance when we go to forward slash,
which is the index page, right?
It's gonna do a GET,
and it's gonna render this template of index.HTML,
and that is in here under static templates, index.HTML,
and you'll see here, this is how the page is laid out.
There's some dynamic data here.
We're using some if,
and it's gonna loop through messages should they exist,
and we'll look at how that works here,
and then we'll see there's a form
that's doing a post to add compliment.
Let's look back to app.py,
and see how these two line up.
So it's gonna come in, and it's gonna call,
get sent messages, and get some messages is not implemented.
I left this here as a to do so we can fix that as it goes.
So, and then it basically pushes those messages,
and sends us an empty list.
It will just go.
So in here we can see that there's an add compliment,
and it's a happening when a post happens.
So it's gonna run this function when a post happens,
and again, that post was happening from the form,
and we'll see what's happening is
it's just pulling off these variables is
we've got sender receiver compliment
that's pulling off a two,
and if we take a look at 'em back out here,
if we look at our form, we will see that we've got,
there's the two, and you'll see the name is two.
So that's what's getting pushed across,
and their sender, and receiver, and compliment.
So they're pulling us through.
It's kind of building a message for you.
So sender says,
and she's using that F string right?
Sender says receiver is compliment,
see more at request.URL,
and we'll send that message to body.
So it's gonna call, send message,
and right now send message is needed to be filled out.
So this to do here
is actually a pretty good place to start, right?
We need to send the text message,
otherwise there's no messages to show,
and we know how to send text messages
using a RESTful API, no sweat.
We can do that.
So I could use the Python HTTP client,
and write my own messages.
That seems like a lot of extra work, right?
So I'm gonna use the Twilio Helper Library.
So in Glitch you can access the terminal
from your application by down here.
If you go into this clip tools,
and you come up here to logs,
and then come over here to console,
and see that I've now got a terminal running,
which is pretty powerful, right?
So I'm gonna type source.
and then it's .venv/bin/activate.
And remember we had done that before.
So we're gonna activate script now we're activated,
and you'll notice that I've got this this year, this venv.
So now I will go ahead,
and I'll do a PIP install Twilio.
So we'll get down that Twilio Helper Library
so that we can use it in this application.
Awesome, so it's all installed.
So we should be able to use that.
I'll go ahead, and close this, and it went,
and it downloaded everything that we needed, right?
So it got it, but if someone was to come along later,
and use it the way that it knows what to install is
there is this requirements.txt file,
and you'll notice the Twilio stuff isn't in there.
This is just got the stuff for Flask,
Jinja's part of Flask,
and Werkzeug is also part of Flask.
It's got just the stuff that was needed
so they won't have the Twilio Library.
So we want to get the Twilio Library in here.
So the way to do that is
let's get back in here into the console.
So first again,
we're gonna activate source/venv/bin/activate.
Okay, so we're gonna use PIP freeze
to show all of the packages that we have installed,
and then we can store its output,
and we can do that in this requirements.txt.
I'm gonna go ahead, and do that,
and when you make a change in the console,
you have to do refresh to make sure that it shows up.
So now if we look in here,
we will see that we have Twilio is now available
for whoever comes to use this later.
Cool, let's write some Python.
Okay, so back in app.py.
I'm going to come in here,
and I'm gonna say from Twilio.rest, import Client.
So this line here,
this load.env will load environment variables
from a secret Glitch file that I have over here this .env.
I started it for you.
Now why don't you pause me,
and go get your keys,
and phone number,
and fill this file out.
This is kind of like the environments
that we saw in Postman.
So go get those.
Do you know where they're at?
Go ahead, pause me,
and when you're already unpause me,
and I'll show you how I did it.
So here's how I did it.
I wait till my Twilio console,
and I copied my account SID,
and then I went, and I went to my Auth Token,
and I copied that, and I pasted that there,
and then of course my TWILIO_PHONE_NUMBER
is my trial phone number right here,
and I'm gonna paste that here, and save that,
except I don't need that.
There we go.
Cool, so let's flip back to app.py.
And if we take a look here,
there's a thing called TWILIO_PHONE_NUMBER,
and it's using this os.getemv
for a GET environment TWILIO_PHONE_NUMBER.
So it's pulling that from here.
So in our application,
automatically this will be set up.
Nobody else can see this.
This is your personal information,
but here I've got that stored in a variable.
Pretty cool, right?
So let's go ahead,
and let's create one of those clients, right?
So we'll say client equals client,
and here's a little fun fact.
If you don't pass any arguments
to the client object on creation,
it will look in your environment variables
for those Twilio underscore values.
So like the Twilio account SID,
so environment variables
are an excellent way to keep your keys hidden,
and not leave them sitting in the front seat.
Check the notes for how to do that locally on your machine.
So now we have an authenticated client
that we can use to complete these to-dos.
So the first one I think we should do is tackling that,
sending the message, right?
That was down here.
We're gonna send this message,
I'm gonna come in here,
and I'm gonna delete this keyword called pass.
And I'm gonna start with actually, you know what?
You got this.
Go ahead, and write the code to send a message.
Now don't worry if you didn't memorize the syntax,
I've put links in the notes
to the Twilio docs ready?
Pause me and write the code to send a message
using the to, the body, which is come here, right?
So we've got the two in the body coming in,
and all you need to do is set the from,
and you can set that from your Twilio number here.
If you do it right, and fill out the form,
you should get a text to your phone number.
You've got to text your number.
So a couple of gotchas in Python spacing matters.
So make sure that you're indented under the function.
See how this is indented here?
Make sure you're there,
and remember that from, F-R-O-M,
from is a keyword in Python.
So it's from underscore, right?
Write some code to send a message, pause me,
and then I'll show you how I did it.
You got this?
How'd you do?
So here's how I did it.
So I use the client,
and I use messages create, and I passed in two,
and that's the, what's coming in from the function there,
and the body is also what's coming
in front of the function there,
and then I had to use from underscore,
and I'm gonna say the TWILIO_PHONE_NUMBER.
And I'm gonna click the Show in a New Window.
Cool, so we're gonna text my number here.
So that's plus 1-053-461-5537
and we're gonna compliment me.
Person to compliment is Craig,
we're gonna say Craig, Craig,
is completing to-dos
and we're gonna send the compliment,
and I should get a text.
It says that my message was sent successfully, and awesome.
I got it, and now I'm gonna remove that to do,
I'm gonna feel good.
I love removing to-do's.
There's nothing, nothing better than that.
So what do you say we get the next one?
Let's do it, we can do this.
Make this return a collection of messages
that were sent from the number.
Should we do it?
Let's do it.
So get sent messages is used in this index function, right?
So that's what's pulling out the messages.
So let's take a look again real quick at that template.
Yeah, so it's saying if messages,
if there are any messages for message in message,
write out the message body.
So that's gonna just loop through those messages.
So we are going to pass through the message object,
a list of those message objects.
So in this GET sent messages,
we see that it's an empty array,
so that's why it's never showing up.
So we want to replace this with a call
to get the client call log, right?
Do you remember how we did that?
Okay, you have the link to the doc.
So go ahead, give me a pause,
and see if you can't get it.
If you get it, and refresh the page,
you should see the message, and recent messages.
I'll show you how I did it after you unpause.
You've got this.
Okay, this is how I did it.
So I used client.messages.list,
and remember we could be using an account
that has multiple numbers.
So we really only want to get the messages
that were sent from our Twilio number.
So again, that's from with an underscore,
and we'll do TWILIO_PHONE_NUMBER.
So that's a way of querying that, right?
So we're saying we only want messages
that were sent to the TWILIO_PHONE_NUMBER,
and if I come over here, and refresh, there it is.
Craig says, Craig is completing to do's.
See more compliments at HDP complimentary.Glitch.me.
So yours will be whatever yours is there.
Pretty cool, right?
Great job getting that application up, and running,
because it's actually running.
You could totally share that out now
by sending a text message to someone you trust.
Wait, well actually, maybe you can't.
I seem to remember something about our accounts
being limited verified numbers only while in trial mode.
Now, API limits are probably something
that we should look into really quick,
since they're pretty common
with every API that you might encounter.
Let's take a quick detour,
and explore some limits,
and then we'll get right back to implementing this app
APIs are designed to have limits.
As you can imagine,
if you were the maintainer of a web based API,
you wouldn't want someone making millions of requests
in a short period of time.
The chances are your API server couldn't support the load.
The typical solution to this is the throttle,
or limit the number of requests
that you can make per second.
Typically these limits are introduced
when you get your API keys.
If you'll recall on the Twilio console
where we got that trial number,
we were informed that
not only will messages we send during the trial
have that trial text that we'd been seeing,
it also said that we can only send a verified numbers.
What do you say
we see what happens if we try?
Now, I don't know about you,
but I find that having people that support you in your life
to be super important.
Now for me, hands down, that person's my mom.
Like no matter what I'm doing,
she's just there in the sidelines cheering me on.
Whenever I launch something new,
you can pretty much guarantee
that she's helped me test it out.
So I'd like you to do this.
I'd like you to think of someone like that in your life,
and I'd like you to send
them a compliment using Complimenter.
So I'm gonna add my mom here.
So I'm gonna add her number,
and that is 1-602-609-5813.
So used to just pressing mom on the phone, right?
So I'm gonna say my name is Craig,
and I'm complimenting mom,
and mom is infinitely supportive
as you'll soon see, I'm sure.
So obviously you should put in your friend,
or family or colleague here.
Here we go.
Alright, so I'm gonna click Send compliment,
and ooh, no, internal server error, yuck.
Let's go, and look at our logs,
and see what happened.
So I've got a pretty big stack trace here
of what happened on add compliment,
and if we come down here,
it says the number is unverified.
Trial accounts cannot send messages to unverified numbers.
Oh, right, verify.
Oh, we can verify them at Twilio.com/verify.
Let's go ahead, and do that.
Can I can do that?
Go to awesome.
So now I need to get my mom's number in here.
I need to get her to be verified so that she can see it.
So you can actually do this pretty easily,
and what this will allow me to do
is to be able to have my trial account be able to text her,
which is all we need, right?
So what I'm gonna do is I'm gonna click Add,
and they will call you with a verification number,
or I'm gonna make it text you instead.
So what I'm gonna do is I'm going to put in
my mom's number here,
put in (602) 609-5813.
So what I'll do now before I click the Text Me,
is I'll say, hey mom,
I'm texting her this it's me again.
Hey, I'm going to verify your number.
You're gonna get text from Twilio.
Can you send it back to me?
And she wrote back.
Sure thing sweetie, aww.
Okay, so now that I know she's ready,
I'll now send that validation message,
and so I'll click Text Me,
and I will wait for my mom to tell me what that was,
and then she should be able to send me the code.
Okay, so she texted me,
and that number is 946541,
and then I click Submit.
Awesome, so now my mom is verified.
Here she is.
She's in this verified numbers.
Now I can text her now let's go try that again.
Let's get back to this internal server error,
and I'm gonna refresh.
Reload that, and it's gonna say
you're gonna submit the forming,
and that's totally fine.
That's what I want it to do.
It's actually what I want it to do,
and we say continue, and boom, we did it,
and my mom should get a message, and she did.
She just sent me an emoji heart.
I hope you're now able to show off your app
to your supportive person.
It's really nice to have that support as you're learning,
and building things.
If you don't have someone like this.
My mom's pretty supportive.
If you want to just text her,
I bet she'll shoot you back some words of encouragement.
No, of course this app isn't gonna go viral
in this trial mood,
but this is a great prototype of the concept.
Most of the time APS will give you a chance
to get your prototype together
before they start charging you,
but being aware of the limits
will help you plan your efforts.
Remember to carefully read the limits, and error messages.
Most API will guide you into how to deal with limitations.
Now let's get started with
Now we're gonna implement
that same Complimenter application,
and ready for us to tweak.
and there's some front end code
On the server side,
the application uses Node.js,
and the web framework express.
On the front end I've used the client side framework view.
The Python version that we saw earlier was all server side.
There is some things to consider when implementing
a client side application when using an API.
So let's explore those
In the notes,
I've supplied a link to the repo
that you can use to create the new Glitch project.
Go ahead, and copy, and paste that.
I'm gonna click Clone From GET Repo,
and then I'm gonna paste the repo.
Alright, so we're gonna do the Node version.
So this is Node,
and again, if Glitch takes a while to spin up, that's okay.
It might eventually show up,
or it might Glitch out,
and if it does Glitch out like this,
like sometimes I might just say the assets folder,
just go ahead, and do it again,
and it'll eventually work for you.
Awesome, here's mine working.
as a very simple Single Page Application, or SPA,
and what that means is that once the page is rendered,
the client will responsible for rendering parts of the page.
We won't rely on a full page reload from the server
to load new pages for us.
Let's take a look at app.JS
the server side of our application.
So we're gonna look at app.JS.
So let's see this first .env here.
This will load up our environment variables,
which we'll take a look out here in a second.
Then it's using express,
which is a web framework,
and you'll note that it's exposing static files
in a public directory.
So this is a single page application,
and it's rendered in publicindex.HTML.
Let's take a look there, Publicindex.HTML.
So this here is the view dependency.
If you haven't seen view before, no worries.
This is a pretty straightforward way of using it.
So what View does is it uses these V dash, right?
So it's these V dash attributes,
and those are view specifics.
So basically this is saying
if the compliments that length is greater than zero,
and we'll see how compliments is defined here in a bit,
and as you can see if it does exist,
it's gonna loop through each one of the compliments,
and then it's gonna write them out.
So it's gonna write them out
using that double mustache syntax here.
So it's gonna write out
the compliment that's in this loop.
Okay, so that compliments variable
is initialized in our application.
Let's scroll down to it.
I've put the whole application in one single file here.
So we don't need to worry about packaging, or anything.
So the way that you create a new view app
is by saying new view,
and you can see here there's this data attribute,
and as you'll see,
compliments is initialized as an empty array.
You can add instance methods to your application
by adding a methods object in the view constructor.
So we have a method here called refresh compliments.
Now you might not have seen this before,
but if you've had a hard time
keeping track of promise based codes in the past,
this feature here is the one that you've been waiting for.
You'll see here that the keyword async
is before the name of the function.
So it says async refresh compliments.
Once a function is labeled as asynchronous,
you can now cause functions that return promises
to behave synchronously.
Meaning they don't move on to the following line
until it completes.
So this line here makes a fetch, right?
So fetch returns a promise,
but there's a keyword here of oh wait, right before it,
and this code will wait for the fetch call to complete,
and then assign the future value of
whatever this is into the response.
In the same is true here
response that JSON returns a promise,
and this will wait until this is done.
One thing to note is that this async function
makes it so that refresh compliments now returns a promise.
That is it's return value will have a then method
that returns this value.
Now if that doesn't make sense just yet,
just you await it will.
Just try, and let it all async in.
A dad joke, double whammy.
Sorry, I'm kind of obligated
to make all these jokes.
Really though, most devs that I talked to
find this async await
more straightforward to use than promises
for code that's actually synchronous in nature.
Alright, so what is this code doing?
So it's making a GET request.
Fetches default method is a GET
to a URL of /API/Compliments.
So that's in our server side code.
Let's flip back to here to app.js,
and you define routes with express using this app.GET.
So whatever the HTTP method name is.
that's what we saw.
So when that happens, this function here will run,
and we'll pass in the request,
and the response,
and here's our first to do
so we want to get the message log.
So first before we do that,
we better install the Twilio Helper Library using NPM.
So I'll click on Tools,
and then I'll click on this logs,
and then I'll click on Console.
Now I'm gonna run NPM install, install Twilio,
and I'm gonna do --save.
What that will do is it will update a file called
Package.JSON after it installs,
and this is much like we saw in the Python library,
we did the freeze, this --save will update that file
so that the Twilio dependency is there.
We'll let this complete.
Awesome, and so now when you make a change from this side,
we always need to say refresh
so that we can refresh the project,
and see the changes that we made,
and so if we look in here under package .JSON,
you can see that there is a dependency of Twilio.
Great, so now that we have things installed,
let's go ahead and update the in the .env file.
So that's this key.
See this little key.env here?
This is gonna allow us to put our information in here.
So I'm gonna go ahead,
I'm gonna grab my account SID.
You should do the same with yours,
and grab my Auth Token,
and last, but definitely not least my phone number.
Alright, and now we can use that in our code.
Let's go right above this port.
Right below this port here.
We'll make a new Twilio client,
and we'll require,
actually that probably looks better
up top a little bit more.
Let's move that.
Let's do that right.
This is all out of alphabetical order, isn't it?
Let's do this right here.
Here we go, and then we can instantiate one
that will look better down here.
So I'll say const client equals new Twilio client,
and again, it's gonna pull from the environment variables
of the Twilio underscore,
and just to show you how you do that here.
So we'll say const the TWILIO_PHONE_NUMBER.
If you ever wanted to
pull something else out of the environment,
you use process.env.thething.
So the thing was called Twilio,
I think it's called phone number.
Let's double check TWILIO_PHONE_NUMBER
Yeah, cool, awesome.
So let's get that message log.
So what I'm gonna do is I'm gonna replace this.
So we're getting the compliment.
So we're getting sent messages.
So this to do get a list of messages
sent from a specific number,
obviously Twilio number there.
So what I'm gonna do is
I'm gonna replace this array with my code,
and actually you want to give this a spin?
Well, one thing to note
is that the function is marked async.
So you can, and you probably should use
the keyword await, right?
So this is an async function.
So make sure you use the await keyword.
Are you ready?
Just make the call to the messages API
to get a list of messages
that were sent to a specific number.
Like the to-do says.
Don't worry if you don't have it memorized,
I put a link to the docs in the notes.
Go ahead, and pause me, and give it a shot.
When you unpause me, I'll show you how I did it.
How'd you do?
So what I did was client.messages.list,
you pass in an object with the parameters.
So we say from not a key word here,
and we'll say TWILIO_PHONE_NUMBER,
and like I said, we should make this be a wait,
because we're gonna wait for that to happen,
and boom, just like that of that to do,
well, why don't we change?
Why don't we take a look, let's go.
I'm gonna change this to be Complimenter of a mentor
that's not very nice to Complimenter.js.
Compliments, I'm gonna close that, and let's go ahead,
and we'll do show
when we should see the messages come through.
Oh, we shouldn't see the message come through yet, right?
Because we aren't passing anything through.
We're passing down these compliments.
Alright, let's see.
Let's see if we can get this next to do done them.
Gather only the body of those messages
for sending to the client.
Okay, oh right, because we don't want to send
down the whole message object to the client.
So what we want to do,
the API is called compliments, right?
And we have an array of text messages.
So more importantly though,
if I were to send down this message,
each one of those messages,
it contains a bunch of informations
that I don't think we want to share with everybody.
That message has the phone number
of the people who sent the message.
I should never send information
that I want to keep safe down to the client.
So really we only want the body.
So let's see, I have an array,
and I want a new array of just message bodies.
Now to me, this sounds like a great use
of the array.map function.
So sent messages is an array.
We'll say sent messages.map,
and the map function,
map takes a function that will receive
each value in the array.
So that will be a message,
and it takes a function,
and if it's on one line,
we can skip the return keyword,
and just put what we'd like to see.
So this compliments array,
we want to see the array of message.body, right?
So what this is saying is like
for each of these messages in here,
just return the message body,
and put it in compliments.
Makes sense, and then it's gonna send down
the JSON representation of that to our view client.
Should we see if it works?
Alright, we'll save this,
and now, oh, there we go.
It's working already.
So we'll see.
There's a new one from my mom,
and it says, mom says,
Craig is so proud of you, sweetie.
Oops, it's nice, it's sweet.
She wrote back, and that's what I love about
having someone use your applications.
It looks like I still have some UI work to do
to make it more clear about what's happening,
because my mom wrote
so proud of you sweetie in the compliment,
and that doesn't make much sense, but I feel nice,
and again this is using the number,
this was not sent from this app.
You can see it was sent from the Python app, right?
This is Complimenter.js,
but this is using a different data source,
and you know what?
While we're here,
why don't we look at how easy it is to see
what the data was that was sent down from the server?
So I'm gonna right click,
and I'm gonna choose Inspect.
I'm gonna click on this Network tab here,
and I'm gonna refresh the page,
and you'll see it make that request.
So if I click on this Compliments here,
you can see here is the message.
Here's that array that was sent down, right?
You can imagine that if we sent down all of those messages,
we'd have that data very easy to get.
So again, this is the developer toolbars
if you say View, Developer, Developer Tools,
you'll be able to see this.
I'm gonna take a quick break,
and then I'm gonna swing right back,
and finish up the remaining to do,
creating a new compliment.
(calming electronic music)
We just finished displaying a list of all the compliments,
and now it's time to deal with
So let's keep the front end code,
and see what happens.
So that is in publicindex.HTML.
So here's that form.
Alright, so we have this it's a form that goes to post.
It goes to /add compliment,
and it's got these V dash models.
So here's like V dash, model two, Videsh model sender,
and that's how view does data binding.
So anything in that field will be bound to that variable,
and if we come down to the button here,
we will see that the normal click, it won't,
it will prevent, right?
So that prevents it from being submitted,
and it calls this send compliment method,
which is defined in the method stanza here,
which is this send compliment.
Okay, so it goes ahead,
and it grabs the stuff from the form
so it pulls them all off.
They also happen to be the same,
it's in a thing called data, then it uses fetch,
and it uses it synchronously, right?
So it's got an a wait, it's gonna wait for fetch to go,
and it passes That as JSON,
and were saying that it is JSON,
and we're passing JSON up,
and we're doing a post request,
and let's go ahead, and we'll take a look in app.js,
and we'll see here that we're using this body parts here,
so any request that comes in will automatically get parsed,
and the way that that looks is a,
so here's this post, right?
So here's, we failed, we fixed this get,
and we got to get rid of these two do's.
Forgot to erase those.
Those are to-done.
Alright, so it comes in here,
and it's posted to API compliments,
again, an async method.
So it's gonna pull off of the request body too right?
So, and because of the body was parsed,
it's automatically inflated here.
So body the two,
it's gonna pull the two off of the field,
and request that body sender,
or Costa biosphere, very compliment,
and it's using the Bactec
so it's automatically filling those out.
So here we are.
Here's our to do.
Why don't we just synchronously create that message?
Well, you want to give this to do a try?
Go ahead, pause me.
I put links in the notes,
I'll await for you to unpause me,
and then show me how you did it.
How'd it go?
Here's how I did it.
So we want it to be synchronous.
So I'm gonna go ahead, and use await,
and I don't really need anything from the create a message,
so I'm not gonna assign a return value,
and I'll use the fact that the parameters are the same.
So I'm gonna say client.plant.messages.create,
If you have a variable named two,
it will just set 2:2 from embody, right?
So this is just basically,
because there is a variable called two,
it knows to make a new one called two in this array here.
Alright, so let's give that a go.
So I will go ahead, and click Show Here,
and I'm gonna send another one to my mom.
To mom, no, my name's not mom.
Well my name's Craig,
and I'm gonna compliment mom.
Her compliment is a really patient tester.
Mom is a really patient tester.
So here we go.
Yep, there it is.
So see right away it came back,
and you'll see that the forms cleared.
So let's see how it did that.
So back in the index.HTML we have this,
we posted it, and it got back the data,
and it awaited for the result,
and then it wrote out the result,
and we saw this information come down.
So we could actually,
if we wanted to,
we could do View, Developer, Develop Tools,
and we should see in the console.
Here's the object that got sent back.
So it was a success of false.
Now, we forgot to update that, didn't we?
I'll have to look.
I thought we looked at that.
Now, if you're gonna say, yeah,
that was a successful journey there.
Glad we caught that.
Speaking of catching stuff,
what happens if things go wrong?
So much like before when we needed to capture the error
using the catch method on promises,
we need to do something similar in this async await land.
So we need to use a standard try catch block.
Now if you haven't seen that before it's,
it's pretty straightforward.
What you do is you say try,
and if any error at all is thrown
what will happen is it will call this catch block,
and it's a good way to handle errors.
So we're gonna catch that error.
So the error object has a status,
and you can send that down to the client
by saying response.status, and we can do error.status.
We'll just pass that status straight through,
and this is changeable.
So we'll send JSON, might as what happened.
So we'll say success is false for real this time,
and we'll also send,
why don't we send the message,
we'll send that error error.message.
There we go, and you know what?
We can use prettier here too.
So we're gonna click this format, this file.
Let's make this thing prettier.
Okay, so we're going to try, and if there is a failure,
we're gonna send this back,
and then otherwise we're gonna go ahead,
and send down the success of true.
So we got to break it somehow.
How should we do that?
Let's say instead of from, let's make this be 42,
the meaning of life, and everything.
So that is obviously not a valid TWILIO_PHONE_NUMBER.
So let's go ahead,
and let's bring up Complimenter,
and I'm just gonna oh, it did refresh.
I was gonna refresh it, and it did for me.
So we'll send another message to my mom.
My name is Craig to my mom,
and the compliment is good at catching errors.
Okay, and I'm gonna click Send a Compliment.
Let's see what happens.
Oh look, so here we got the error.
It's a 400 that came back,
and the from phone number 42 is not valid.
CMS capable, or inbound number,
or short cover from your account is a better version of it.
And let's make sure we don't leave that in that state.
So we'll undo that, and save it,
because I want my mom to give me another compliment.
Again, we are good to go.
You've now used an external API
in two completely different web frameworks,
and paradigms even.
you should be sending a compliment to yourself.
You're accomplishing great things.
Way to stick with it.
One other thing I'd like to take a quick moment
to point out is that the server code that we wrote,
you might've noticed it was prefixed
with a /API server code
that interfaced with a client.
Now here's my question to you.
Do you think that the API code
that we wrote together should be considered RESTful?
Why don't we take a look at our
weathered scavenger hunt card?
So it's definitely a Client-Server Architecture.
Our client happens to be,
in this case, a view application running in the browser,
and our server is a Node.js server,
but any client could connect, and use this.
It's definitely Stateless, right?
We aren't requiring any prior knowledge about the client.
Well, at the moment we aren't providing
any caching information so we could, right.
We could fairly easily pay attention
to those headers coming in, and respond appropriately.
It would require us writing some additional code,
and thinking through some edge cases,
but we could do it.
Let's put this in the maybe column.
Yeah, for sure, right.
In fact, it's a little layered already.
Our API is calling another API,
but our client doesn't need to know that.
We could also add additional functionality,
and the contract wouldn't change.
We haven't even talked about this one yet,
and it's the only optional requirement.
Now basically this means your API returns code
that is runnable,
like maybe it returns an embeddable widget,
This doesn't make sense on our application,
and that's okay.
I'm gonna drop this one in the no,
so we're looking good so far,
but here comes the doozy.
So remember this one has four subsections, rut row.
Currently we're just representing
all the complements as strings,
and absolutely no way to identify them.
So we fail this sub requirement,
and therefore this thing is a no,
but let's keep going through the rest of these.
Pun intended, sorry.
We definitely do not allow
any sort of manipulation of compliments.
So this is another fail.
We haven't gone over this yet,
but by using headers we can tell that this is JSON.
The message sent down has a type,
and it is clear that it should be JSON decoded to be used,
and last, but certainly not least,
Hateos, or Hate OS is an often forgotten about part
of the RESTful constraint, and very hard to say.
The idea here is that there are links provided
to show off what more you could do with this,
and where you could find related resources.
It provides URIs, or links.
We did see this in both the Spotify, and Twilio ones.
However, ours doesn't need to provide links
to other resources.
So we don't have a RESTful API,
and that's okay.
It works as is.
It does look like we could get there pretty quickly
if we wanted to.
One thing I want you to gain from that exercise
is that you now have the ability to identify whether,
or not an API is RESTful,
and I hope that felt pretty good.
We've now completed that scavenger hunt.
We revealed all the constraints,
and I hope that most of those are pretty clear.
Please don't feel like you need to memorize those.
You can find these same constraints
littered all over the internet
as a prize for finishing the constraint scavenger hunt,
I've dropped links to my favorite
REST API constraint documentation for you to lean on.
I've also included links to popular REST API frameworks
that will help you design RESTful APIs.
Make sure to check the notes.
You did it.
You just completed a whirlwind introduction to APIs,
and I hope you see how much power
they can add to your programming journey
by looking at interfaces in general.
I hope you're more comfortable with the idea
of not fully understanding exactly how something is working,
but still leaning on that abstraction
to build your tools, and applications.
We do this all the time with physical object interfaces,
or Application Programming Interfaces
aren't all that different.
I hope you enjoyed taking this course.
I know I had a ton of fun making it.
If you think someone you know
might benefit from this course, share it with them.
I'd love to hear your feelings,
your thoughts, and your dreams.
So I threw together a little something
using a smattering of API's to capture your feedback.
If you've got the time,
I'd love to have you answer a quick text based survey.
Text feedback to 1-503-461-5537.
Actually, you know what?
If you want to, you can also just call,
and leave me a message too.
I used an API for that too.
Please, please, please keep me posted on your journey,
and really I can't wait to see what you build.
Thanks for hanging out.
(calming electronic music)