for the first time, but the humans didn't steer the rocket.

It steered itself using a computer.

- [Man] Tower, clear.

- [Man] Gotta roll program.

- A lot of the Saturn V rocket was built here

in Huntsville, Alabama, otherwise known as Rocket City.

And one of the really cool things about living here

is it's filled with aerospace and computer engineers

who love this stuff, so a thing you can actually do here

is pick up the phone and call one of your friends

and have them call their friend, and before you know it,

you're in a parking lot, receiving a Saturn V

memory module from a guy you just met,

and he just trusts that you're gonna give it back to him.

This is 14 kilobytes of data, which is really interesting

because the same day I got this,

I had Linus Sebastian from Linus Tech Tips here.

We were installing a server that was over 100 terabytes.

Now, millions of people look to Linus

to understand more about modern computing hardware,

so I thought a really cool thing to do

would be stop what we were doing with the server

and take a closer look at this memory module

and how it works.

Let's sit back and watch a modern computer nerd

learn about the cutting edge technology from the 1960s.

I'm Destin, let's go get smarter every day.

- [Destin] Have you ever seen a Saturn V rocket?

- [Linus] No.

- [Destin] Okay, do you know what the Saturn V is?

- [Linus] Yes.

- [Destin] My daily life literally revolves

around the Saturn V.

Like, that's the Saturn V peeking out

over the trees right there.

- [Linus] Oh, there it is.

Hello.

- [Destin] In the 60s, they had just started building

digital computers, and I'm gonna show you the computer

that they used to steer that thing.

- [Linus] I mean, it's gotta be a bit

of a terrifying experience having, like,

the equivalent of a very large bomb

strapped to your butt.

- So this is the brain for the Saturn V rocket.

If you look up right here, this is the instrumentation ring,

and so they had computers on here that were digital.

This right here is the launch vehicle digital computer.

That is it.

This right here is a memory module, okay?

And if you look really, really, really close,

really close, you see those little bitty rings?

- Yeah.

- [Destin] OK, look right here.

Look at that.

Do you see that?

- [Linus] Holy smokes, so they're,

it looks like zip ties on chicken wire.

- [Destin] Okay, those are bits.

Those are physical bits.

So you see that screen?

- [Linus] Yeah.

- [Destin] These are wires that go down

to these boards right here, right?

- [Linus] Yeah.

- [Destin] On each node, you have an iron ring,

and depending on how the iron ring is magnetized,

that's a one or a zero.

That's how they programmed this computer.

Seriously.

So look at this right here.

- So by hand.

- [Destin] By hand, yes.

- They threaded these wires through the,

I mean, who has a steady, I don't even think

you can build one of these today if you wanted to.

That's incredible.

- [Destin] So there's a guy that worked on this

in the 60s here.

His name is Luke.

- Yeah.

- [Destin] And, you get ask him all of these questions.

- Fantastic.

- I'm Luke Talley, and at this time in 1969

I was a senior associate engineer at IBM in Huntsville.

- [Destin] So your computer pointed the rocket?

- That's right.

- [Destin] Awesome.

- We steered the rocket.

So that's a memory module.

- [Destin] That's a whole memory module, yeah.

- You musta shot somebody to get that.

- [Destin] So how valuable would you say that is?

- Well, now this, ah, I don't, I'd have no idea.

You have to go to Antique Roadshow.

This computer controls all the timing.

Start engine, stop engine, fire separation rockets,

fire retro rockets, all this kinda stuff.

It does navigation and guidance.

You have stored in the memory a profile,

at this point in time I need to be here,

going this fast, going this direction.

Now realize that this is core memory,

so you have these magnetic cores,

you have the wires feeding through the cores,

you push a current down through a wire,

if you've got a wire, current's going in that direction,

the magnetic field is going to be in this direction.

If it's going this way, it'll be that way.

Make that a one, make that a zero.

There's 8192 of those on this plane, all right?

- [Linus] Yeah.

- Then there's 14 of those planes stack up

to make this module.

This module is what you're holding.

All this stuff now, the drivers to drive this thing.

- That's just to program it as a one or a zero.

- Because this is basically an analog process.

- Right.

- I'm not writing ones and zeros into a logic gate

and storing them that way.

- You're just sending a current --

- I'm actually having to make, magnetize a core

one way or the other.

And then I've gotta read it, and when I read it,

I destroy the magnetization, so I have to turn

right back around and --

- Write it again.

- Write it back in there, so that it's not missing.

- Oh, no!

- So there's one of these in this,

and then there's one of these now

in each one of these blocks on this wall over here.

- [Linus] Got it.

- So we have four, 8, 12, 16 thousand words of memory,

another four, 8, 12, 16 thousand words of memory.

Now when the Saturn's flying, both of these memories

are executing the same flight program.

- [Linus] Completely in parallel?

- That's right, and they're comparing the outputs

to make sure they're getting the same answer.

If they were to not get the same answer,

go into the sub-routine and say,

"I'm at this point in the flight,

I got these two numbers, what makes the most sense

to keep using," use that number and keep going.

So your critical parts are triple-redundant

in the logic, dual redundant in the memory.

As I recall, during all the Saturn flights,

we had like, less than 10 miscompares,

something like that.

It was a very small number.

- When you're building a rocket,

you have some important parameters

that you have to monitor.

Power, data bandwidth, mass, volume,

you have to manage these so they don't get out of control.

So you want a reliable system, but at some point,

you have to make a decision.

How redundant is redundant enough?

- Unreliability, that's the key,

because the more of these things,

the more core's you add, the more of this stuff you need,

the more unreliability you add to your system,

because sheer numbers of parts.

- Right.

- Luke is about to explain what it was like

to receive data from the Saturn V via telemetry

and then analyze it, and I'm gonna let this play out,

because I want you to understand how repetitive

and difficult this task was.

Today we could do this with just a few minutes

and some spreadsheet software, but back in the day,

they were the computers.

Like, the people were the computers.

So I want you to see it through his eyes,

through this historical lens so you understand

what it was like to analyze the Saturn V data.

- So did you pull the data down while it was flying?

- Things happen too quick in flight to.

- [Destin] How do you know you had --

- We get the data back and then we ana,

that was my job at IBM, was we were analyzing

the flight data to determine what worked,

what didn't work, if it didn't work on this flight,

how do we fix it on the next flight?

- Got it.

- And then when you get the NASA requirements

for the next flight, make sure we got everything

in place to do what we were supposed to do,

so the data tapes come from all around the world

through Goddard Space Flight Center's responsible

for that, so they get us the data and then we analyze it

and determine what happened.

Something would go wrong in the computer,

and it always goes wrong when something else

is messing up the telemetry system, so we would

actually get what they call an octal dump.

We have this 11 by 17 sheet of paper, 10-bit octal numbers,

so you'd have, there were four characters.

Zero to seven's as high as you go with octal arithmetic.

So you got all these things, I think it was like,

maybe 40 columns and 30 rows or something like that,

so we would get this thing printed out,

and all it's just numbers, well, the piece we're looking for

is in a particular place down here.

Well, the drop out is where we, you know,

telemetry dropout, we would actually get this printed out

11 by 7 fanfold paper, spread it down this hallway,

get down on your hands and knees,

make a template, cut out the, you'll have a number

of measurements that'll always be the same, you know,

like a bolt, it never changes, so we know what

those number's oughta be.

So we cut the holes out and slide it down

page by page, "Oh, hey, these all look good!

"Okay, this frame's probably good."

So we go find so many columns, so many rows,

find the number we want, write it down.

- So you're looking for one -- - Go to the next one.

- If it bungs up something that you know is a fixed value

then it probably bunged up something else.

- That's right, and if the fixed value's okay,

then somewhere in there our number's probably okay.

- And then once you've got the problematic one,

I mean, is that just the world's nastiest sudoku puzzle?

How do you solve that?

- Well, no, you may have, you may have to do this

for many, many, many frames.

Then you take it to your desk and take those octal numbers,

convert 'em to decimal numbers,

go to a calibration chart and say,

"Okay, I got this number."

Go up my chart and say that means

it's five degrees Centigrade.

So you write down five degrees,

then you figure out what frame you are,

and that's about what time it is,

so you're, "At this time, I had five degrees."

Then you go to the next one.

Now you do this for about two weeks,

and finally you got enough to plot a graph by hand.

So you put all these numbers in

and you plot it by hand, and then you say,

"Hm, that wasn't the problem after all.

"Oh, well, here we go again."

(laughs)

- [Linus] Oh, boy.