Scattered parts into one machine

Connecting the scattered parts

These are the parts we've seen.
The CPU that calculates,
the memory that holds values,
the storage that keeps them even when off,
the input and output we exchange with.
On their own they're just separate.
Connect them through one road,
and only then do they become one computer.

Scattered and connected.

This road is called a bus.
Like a bus stop,
many parts stand on the same road,
and pass values along it.
One computer is
the parts connected by this road.

Passing along the same road

A bus is a shared road.
When the CPU tells memory
"give me that value,"
the value comes along this road.
When the CPU says "store this,"
the value goes along the road to storage.
Press a stop
and watch the value travel.

A value traveling the road.

Because the road is one,
the parts reach each other.
The CPU talks to memory,
and to storage,
along the same road.
Without wiring every line separately,
one road is enough.

Take it out, load it up, calculate

Let's follow one value as it works.
Take it out of storage,
load it into memory,
the CPU takes it and calculates,
then puts the result back into memory.
Because the parts are connected by the road,
this journey is possible.

One value passes through the parts.

Storage is big but slow,
memory is faster than that.
So a value to be used
is loaded into memory first,
and the CPU takes it from there.
Those layers we saw in lesson 13
move together like this.

They travel in turns

Because the road is one,
many can't go at once.
One at a time,
they travel in turns.
A memory value passes,
then a CPU value passes.
It's so fast
that to our eyes it looks all at once,
but really it's one by one.

One road, values passing in turn.

Deciding the order
also happens inside the computer.
Who uses the road first,
it arranges the turns.
Thanks to that, values don't tangle,
and even on one road,
everyone can travel.

All as one body

Now let's run one round.
When we input values (input·output),
they're held in memory,
the CPU takes them and calculates,
and the result passes through memory
and appears on the screen (input·output).
Each and every part
connected through one road,
working as one machine.

Input → memory → CPU → memory → output.

This is the body of a computer.
Starting from a single switch,
we made parts that calculate and remember,
and connected them by one road into one machine.
Next time we'll look back
at the road we've come
all at a glance.