The internet as one giant postal system

You type into the address bar

The journey begins
at the address bar.
You type one line,
the name of where you want to go, and press it,
and at that moment a long trip starts.
It feels like a blink to us,
but inside, several promises
do their work in turn.
The very promises
you learned one by one in this area.
Now let's follow that journey
from the start.

Type the name into the address bar one piece at a time. Once it is complete, the journey begins.

You typed the name,
but the computer still
does not know where to go.
A name is for people,
while the computer needs a number address.
So the very first task is
to find the real number address
this name points to.
Who did that job, again?
Right, it was DNS.

DNS turns the name into an address

The first promise is DNS.
As we learned before,
DNS is like a giant phone book:
give it a name and it tells you the number address.
When we ask DNS
about the name we typed,
the real address the computer will use
comes back clear and tidy.
Now, at last,
we know where to go.
This address is the true
starting point of the whole journey.

Tap to ask DNS. The name you typed comes back turned into a number address (IP). (DNS recap)

The name became a number address.
But knowing the address alone
does not get us there at once.
The way to that address
runs through countless forks.
Data becomes small pieces, packets,
and has to cross those roads.
That route finding and those packets
are all stories we learned earlier.
Now it is time
to begin the real connection.

Connect with TCP, lock with HTTPS

Now that we know the address,
we form a connection with it.
What makes this connection trustworthy
is TCP.
Missing pieces are received again,
scrambled order is set straight,
so it all arrives complete and in order.
Once the connection is solid,
we put a lock on top of it.
That lock is HTTPS.
It locks what passes back and forth
so no one else can peek.

Tap to make the connection (TCP), then tap to set the lock (HTTPS). When both are done, a safe channel opens. (TCP and HTTPS recap)

The connection is formed
and the lock is set.
Now a safe channel is open.
It is a road that is solid,
locked, and trustworthy.
But what we really want
is not the connection itself,
it is the page at the end of it.
One last promise remains,
the one that lets us exchange
the page over this channel.

See the whole flow at a glance

Now the last promise, HTTP.
Over the safe channel,
you ask, "give me this page,"
and the other side replies, "here it is,"
and sends the page.
When that page is drawn on the screen,
the journey is finally done.
From typing the address to the page,
shall we gather the whole flow at once?
Light it up one step at a time,
starting from the bottom.

Tap the steps in order from the bottom to light them up. Address bar to DNS to IP address to TCP to HTTPS to HTTP. When all are lit, the page arrives. (layers recap)

One slot lit after another,
and at the very top the page arrived.
Address bar, DNS, address, connection,
lock, and page,
if any single one is missing
the journey stops.
Each promise trusts the one below it
and does only its own job, exactly.
This stacking up, layer by layer,
is exactly the layering we learned.

Let's wrap up

Gathered on one line, it is this.
When you type an address,
DNS finds the name as a number address,
and packets cross the roads to that address.
TCP makes it arrive complete and in order,
HTTPS locks the channel,
and HTTP exchanges the page.
Packets, addresses, routes, layers, trust, and safety
are all inside this one flow.
This is how the internet turns.

Tap the key ideas from this area in order to review. (packet to address to route to layers to trust to web to safety)

You followed it all the way here.
Now, when you type an address,
you can faintly picture
what happens behind it.
A name becomes an address,
packets cross the roads,
and the promises join hands in turn.
The internet is not magic;
it is a giant postal system
where small promises gather and turn together.
This area closes here,
but now you will see that flow.