The first contract that NASA
secured for the Apollo Lunar program was for a computer to
be built by the instrumentation lab at MIT. You would expect
that maybe it would be for a rocket or a
spacecraft and not a computer. This was at a time
when computers were the size of a room. Humans interacted with them
through punch cards and reels of magnetic tape, not
keyboards, mice, stylists, or touchscreens. Programs are stacks of cards
with holes punched out, and the cards were
fed into the computer, it did some calculation,
and sometime later-- maybe the next day-- it
would print out some results. But NASA needed a
computer that was not only a small,
lightweight, and reliable, but this computer needed to be
able to interact in real-time with hardware and people. It couldn't just sit there on
its own isolated from the world and figure out
its math problems. The computer needed to interact
with astronauts and ground control. The astronauts communicated with
the computer using a display and keyboard called the DSKY. They typed in commands,
selected programs, and requested data
using the keypad. The computer talked back by
displaying commands, programs, and up to three lines of data. If the computer
had a question, it blinked lights on the displays. If it had something
really important to say, then it would flash lights. The computer communicated
with mission control by downlinking and
uplinking data. This special computer was called
the Apollo Guidance Computer, or AGC for short. Its original purpose was
to guide and navigate the spacecraft. We have GPS to help us navigate
when you're walking or driving but there is no solar
system positioning system. There isn't even an up in space. The spacecraft
needed to know where it was, how fast it was
moving, its rate of rotation, and its orientation. The spacecraft's velocity
would determine its orbit and its orientation during a
burn determines its trajectory. There were several
critical burns. Apollo needed to get
into a parking orbit, leave the Earth's orbit to go
to a position the moon would be at sometime in the future,
dock the command module to the lunar module,
park in lunar orbit, undock the LEM from
the command module, descend down to the
surface of the moon, navigate and land
the LEM, launch from the surface of the
moon to rendezvous and dock with the command
module, return to Earth, and re-enter the
Earth's atmosphere. And if you messed up
any of these burns, the worst case scenario is
that your spacecraft is either going to crash into
or entirely miss the Earth, the moon,
or the spacecraft that it's trying to dock with. But the more likely
scenario is that you're going to burn up a lot of
fuel trying to correct any of your miscalculated burns. Some course corrections
along the way were expected. But the more accurate your
navigation and control systems are, the less fuel is required,
and the less fuel the better. That's why we keep discarding
parts of our spacecraft and changing around
its configuration. We need a whole
second spacecraft just to land on the moon
that is tiny and thin. It would completely burn up
in the Earth's atmosphere if it tried to re-enter. But it's only
meant for the moon, and that has no atmosphere. And the ascent
engine didn't have to lift a heavy heat shield. That was still on the craft
that was orbiting the moon. Now that we know that
the position and velocity of the spacecraft
are very important, how do we actually
determine them? For Mercury and
Gemini spacecraft, they were monitored by the
ground using Doppler radar. Gemini did fly the
first onboard computer, but the ground was
still the primary source of guidance and navigation. Computers and mission control
use the position and velocity information from
the Doppler readings to calculate the
spacecraft's state vector. Then NASA directed
the astronauts how to perform their burns. For Apollo, NASA
feared that the Soviets would jam their transmissions. There was also a
delay in the relay of information due to the
distance between the spacecraft and the Earth. And there were times, like when
Apollo was behind the moon, that there was a
complete loss of signal between the
spacecraft and ground. This is why the
original intention for the AGC and its
associated instruments was for it to be the primary
guidance and navigation system. The navigation
instruments tracked where the spacecraft was. The internal measurement
unit, or IMU, measured the attitude, which is
also known as the orientation, and the acceleration
of the spacecraft. The IMU allowed the
spacecraft to carry around its own inertial
reference frame. The gyros and the
accelerometers were mounted to a stable member. Then the vehicle and
the gimbaled assembly moved around the IMU and the
amount of rotation was tracked. The IMU had three gyroscopes
and three accelerometers, one for every axis. And the accelerometers were
pulse-integrating pendulous accelerometers. There was a known mass
that pulsed and acted like a pendulum inside
of a floating cylinder. And when there was a change
in acceleration on an axis, the pendulum created
torque on the output shaft. The signal generator tracked the
rotation and the acceleration changes over time. And when we sum up
changes over time, we're actually integrating. So this gave us the velocity. The gyroscopes work
in a similar manner. Gyroscopes were internal
reference integrating gyros. And when you spin
up a gyro wheel, it wants to keep spinning
in the same direction. A gimbal system can be
built around the gyros. The wheel is going
to stay in place while the gimbals and the
spacecraft rotate around it. Changes in direction would
be sensed by the output shaft of the signal generator. The IMU system was
thermally regulated. And during Apollo 13, they
had to turn the power off to the command module
and the MIT wasn't sure how the IMU would
react after dropping to such low temperatures and
then being warmed up again. And one of the
engineers actually put a gyro out on his
trunk on a cold Boston day before they had to go
and perform some tests. And even in the
best of conditions, the gyroscopes and
accelerometers are not perfect. They were very difficult
to manufacturer with great precision. The instrumentation
lab at MIT was contracted to deliver not
only the computer but also the associated guidance systems. And MIT reached out to
a local watch company and asked for advice on making
these precision instruments. The watch manufacturers told
MIT to build clean rooms. And even with this higher level
of manufacturing standards, the gyros were going
to drift over time and needed to be calibrated. For calibration, astronauts
use methods similar to sailors. They had a telescope
and a sextant. The spacecraft would be
angled to find a landmark and then the astronauts
would superimpose a star over that landmark. To do this automatically,
they could type in angles into the DSKY. And when communicating
with the computer, the astronauts use
verb and noun commands. A verb was a thing
to do and the noun was the object it
was being done to. Verb 41 was point and
noun 55 was telescope. The DSKY would flash,
asking you a question. Verb 21 was load
and 57 was angle. So the computer is asking
you to load your angles. After entering a second
angle, the telescope will slew to those coordinates. If the astronaut aligned
the telescope manually, they can just hit the Mark
button to tell the computer that everything
is ready and then the computer can calculate the
angles between the landmark and the star and this gives
the position of the spacecraft. Star and landmark
charts were woven into the core rote memory. MIT had to make sure that
the astronauts could still use a sextant with
their pressurized suits, and they also needed to
verify that the field of view was not obstructed by
the astronauts' helmets. The lunar module had an
alignment optical telescope instead of a sextant. It used the telescope
to find star alignments and then it coupled this
with radar transmissions from the command module. Between the two of these, it
could figure out its location. The LEM also used radar
to land on the moon and to rendezvous and
dock with a command module after it lifted off from
the surface of the moon. The IMU optics and radar
answered the guidance question of where are we. The AGC needed to
answer the navigation question of where are we going. The guidance system told the
spacecraft the current attitude and acceleration. The computer stored these values
and compared the current state with past states
that it had stored. Then it needed to predict
any future positions and velocities. No sensor is perfect,
so the computer used Kalman filters to account
for any noise that might be in the sensor readings. NASA didn't tell MIT how
precise the calculations from the computer needed to be. There are very few requirements
at the start of the contract. Computers read sensor values
and calculated the state vector much faster than a human
could with a slide rule. Adding more bits to the
computer and therefore expanding the precision would
slow down calculations. It would also require heavier
and more power-hungry hardware. In modern computers,
we talk about having 32 or 64-bit computers. And MIT had settled
on a 15-bit word with an extra bit for parity. This meant that the 15
bits would store a value and the last one would
be for error checking. This last bit told
the computer if there is an even or odd number
of ones in the word. And if the word
arrived and a bit had flipped during
the transmission, then the parity number would
not match the original one and the data would be rejected. The other 15 bits were usually
for a number or an instruction code. Now I'm going to use four bits
in my examples for simplicity and I'm not going
to show the full 15 bits that the AGC would use. Attitude and
acceleration were numbers that could be either
positive or negative, so the first bit of the number
needed to represent a sign. The 0 bit was a
positive value and a 1 represented a negative value. By adding the negative sign,
this cuts our range in half. And to deal with
the signed numbers, the programmers used something
called one's complement. All the bits after the negative
sign would have to be flipped. It's easy to add numbers
on the negative side or on the positive side. Negative 5 plus 2 equals
negative 3 and 5 plus 2 equals 7. And it gets tricky
when we try to subtract because we've created two 0s. There's a positive
and a negative 0. And if we do 5
minus 2, we're going to have an extra 1 at the end. And if we look at this from
the unsigned equivalent, it's like we tried
to add 5 to 13. And this is going to
give us 18, and this is a number outside of our range. This is called an
overflow condition. The computer could handle
an overflow condition but it slowed everything down. It stopped the
progress of programs until it could deal with this
so it didn't lose any data. And most data in the computer
was a single 15-bit word and most operations
used 1's complement. But the IMU radars and
optics were all exceptions. The precision of the
15-bit signed word was not large enough
for the accelerometers and the gyroscope. The computer needed
to use double words for the x, y, and z values
of the state vectors. This meant that there
were two 15-bit sign words that would represent the
value for each one of the axes. And after testing, they
realized that the double 0s of the 1's complement added
errors to the radar gyroscopes and optics. They all had very
specific angles that they needed to be at. And to define a unique angle,
you need a unique value. And for this, they need
to use 2's complement. Everything else was
already in 1's complement, so that meant that they
had to create a conversion. The coupling data unit
was the piece of equipment that would do this
conversion for them. It also converted any of the
analog values of the sensors to digital ones
for the computer. Pretty much the CDU was the
translator between the sensors and the computer. I keep mentioning precision,
and in this context precision is how many digits the
programmers have to work with. Knowing that I
turned 123.45 degrees is more precise
than just knowing that I turned 123 degrees. But that decimal point, though-- that's going to
create problem for us. In modern computers, we
have floating point numbers. A single word stores both the
mantissa and the exponent. This means that we can
store both the value and the magnitude
of this number. They didn't use
floating-point hardware in this computer
which meant that they had to use fixed-point numbers. This means that the
mantissa is the only part that those stored in the word. They later have to multiply this
by a scaling factor in order to get the magnitude back. The programmers had to
make sure that they didn't create overflow conditions
or lose accuracy when they were scaling these numbers. The numbers used in equations
were in metric units, but the astronauts
wanted to see them in English units on the display. This meant that
the numbers needed to be converted before
being shown on the DSKY. The DSKY didn't have a
decimal point, either. The astronauts had to know
the magnitude of the value that they were looking at. If it was 12345 on the
display, in degrees, that would probably be 123.45. If it was a velocity, it was
probably more like 12,345. Programmers had to keep
track of a lot of things. They needed to know the
precision and magnitude of the numbers that
they were working with. They also had to decide
if the numbers should be a single, a double,
or even a triple word. They needed to be able
of scale and convert without creating any overflows. And programming made up for
many hardware limitations. Some of these
hardware limitations went even beyond
the computer itself. NASA asked the programmers to
add a passive thermal control mode. They didn't want
to add insulation to the outside of the spacecraft
to keep the sun-facing side cool. They asked the programmers
to add a constant rotation to the spacecraft
using the thrusters. The spacecraft would be
heated evenly on all sides, just like a nice
rotisserie chicken. This is why it was lovingly
called the barbecue mode. And the AGC's
programmers could do this because control was later added
to the list of requirements. Honeywell was supposed to
build another digital computer to control the engines
and the thrusters. But they were behind. And to save time
and weight, NASA gave this responsibility of
digital autopilot to the AGC. Honeywell would still make an
analog computer for a backup because NASA is
all about backups. The AGC was a backup in
case the Saturn V's launch vehicle digital computer
by IBM had failed. And the ground eventually
became the primary guidance for the command module while
the AGC was the backup-- unless there was a loss
of signal, and then the AGC became the primary. During the landing,
this was going to happen too quickly
for the ground to be the primary for the
LEM so the lunar module had an AGC as a primary and an abort
guidance system as a backup. And if the AGC failed during
the lunar landing, then the abort computer would
return the LEM back to the command module. And the abort computer was
fortunately never used. And the AGC was required to
command the reaction control system and the engines. It could control
them automatically with the digital autopilot
or through inputs from the astronauts. And the computer knew where
it was, where it needed to be, and the error between
those two values. They used this to
calculate the burns. And the RCS thrusters
and the command module engines could
not be throttled. They were toggled. A 1 was for on and
a 0 was for off. The lunar module engine,
on the other hand, was able to be throttled. And the RCS thrusters
could be fired individually or in clusters
to orient the spacecraft. The lunar and command
module engines were able to be gimbled to
align the thrust vector up with the center of gravity. And this is much like
pushing someone on a swing. You want to push them in
the middle of their back so they go straight and forward. If you push them too
hard to one side then they're going to
start to oscillate as they're moving forward. And the center of gravity
was always changing. The thrust vector
need to be trimmed in order to line up with this. During the burns, the fuel was
being used and also sloshing around. And the computer updated the
position and the acceleration from the navigation
system during the burns to account any changes. However, there was no
direct way to measure the rate of attitude change. The attitude is obtained
directly from the gyroscopes. To find the rate, we
need to look at how this is changing over time. And there were
quantization issues. As we talked about in
previous videos, when you go from an analog
to a digital signal, you need to be able to sample
and hold while you're trying to put the data into a bucket. This delays your readings. And you're trying
to quantize the data by going from an
infinite number of values to just a certain
number of buckets. The gyroscope readings were
only 0.01 degrees apart. This value was not small enough. To make up for the
shortfall in information, models of the vehicle were used. These models took into
account the bending moments between the vehicles, the
fuel use, and the sloshing. The computer would periodically
check these calculations that it made with the model
against the actual values from the IMU in
order to verify them. And during the lunar
landing, the computer could also compensate if
one or more reaction control thrusters had failed. The astronauts could let the
computer land automatically but no commander ever did. And the computer
couldn't even tell if there was boulders or
craters, so you wouldn't want to do this anyway. The astronaut and
the computer actually worked together to land. The commander would
select a landing site using the landing point
designator grid on the window. He would mark the
spot that he wanted to go to the digital autopilot. He could then continue to pick
new locations as he flew along. When the craft was
really close to landing, the commander would
then take over. He would use the computer
to help maintain attitude and decrease the descent rate. Every toggle of the switch
decreased the descent rate by 1 foot per second. The commander guided the
LEM to the final spot and cut off the engine when
the contact light came on. There were 3 foot-long probes at
the bottom of the landing pads. These would indicate
contact with the ground, and the commander would
need to turn off the engine before the engine bell
hit anything and caused an explosion. Shutting down the engines when
the contact light turned on would also cause the LEM
to fall the last few feet. If the LEM landed on
some unstable ground, the autopilot would use
thrusters to level it off. This was a lot of things
for a computer to do and the AGC was only capable
of doing one thing at a time. It need to be able to interact
in real-time with humans and hardware but it
had to prioritize what one job it thought
was most important. To make these decisions, it had
an executive and a waitlist. There were major program
modes like Launch, Rendezvous, and Burn. And inside of these
modes, the executive would decide what jobs to run. Each job was given a priority
ahead of time by programmers and the executive would
run the highest priority job for a short,
set amount of time. And then it would look at
an updated list of jobs and see if there's anything
new with a higher priority. If there was, it would run that. If there wasn't, then it
would finish off the job it was currently doing. And once the current
job was done, it would move down the
list to the next item. There was also a
watchman that made sure that no program was hung up so
the jobs list could continue to progress. A version of the AGC
was made on breadboards and tested in hundreds
of simulations. There is no way to simulate
every possible sequence the computer would go through
or every kind of failure. If a program got
hung up or if there was some kind of major
error, the computer could initiate some
version of a restart. It could terminate a
job, it could go back to a saved location, or it could
start a job all over again. Some jobs were so
short that there was no point in restarting
from a saved location. They would just restart
with the next cycle. And some were longer
and the programmers had to build in save features. It would store variables
and locations in the job, and if there was a restart
it would clean up any data and go back to the
last saved location. Jobs could also be interrupted
by astronauts, ground control, or instruments requesting
output or providing input. In computer time,
astronauts take forever to enter any information. Many cycles can be
completed by the computer in between astronaut
key presses. The DSKY job inside
the computer will be put to sleep for a bit
between the key presses so the computer could continue
to do work on other items while the astronauts were
finishing putting in data. Even though the computer could
only do one job at a time, it might seem like it was
doing a lot more, maybe several at a time, to us
slow-moving humans. Engine thrusting
needed to happen at a very specific frame. Some engines are just toggled
on with a 1 and off with a 0. Timers track the
engine's progress and interrupt any
current job to turn off the engine at the
appropriate moment. Any short time-bound operations
such as flashing an alarm light were put onto a waitlist. These operations
were short enough that interrupts were inhibited
until that job was completed. The computer also
had an interpreter that held subroutines and
instructions for frequently used mathematical operations
like addition, subtraction, matrix math, and a
variety of others. And now that we know
the software side, we can dive into the
hardware portion. The AGC had three main parts. There was a logic unit,
an erasable memory, and a fixed memory. The logic unit was probably the
most risky and innovative part of the entire computer. It was one of the
first computers to use integrated circuits. Typically, discrete components
like vacuum tubes, transistors, resistors, and capacitors
comprise the internals of computers. These components were large and
individually wired together. An integrated circuit
connect several components on a single silicon wafer. It reduces component count,
size, weight, and build time. However, integrated circuits
were a really new and unproven technology. The companies making them kept
coming out with newer versions faster than they could
be properly tested. And even with all
of these downsides, Eldon Hall of the
instrumentation lab thought these chips were the
only way that the AGC would meet its requirements. Discrete components
were just far too large. He had to find a sole-source
manufacturer that was willing to make
his dual-NOR chips. And he had to buy them
in such large quantities that he could keep the
supplier manufacturing the same exact chips
for the 10 years that the program would last. To increase demand, he
put these integrated chips into much of the ground
support equipment. And during one year,
the instrumentation lab bought 60% of all the
chips being made in the US. Another hurdle he had
was convincing NASA that they would be
both safe and reliable. The lab put these chips
through every test that they could think of. They put them in centrifuges. They did leak checks, long
duration voltage stress tests, and magnified them under
visual inspections. And if any of
these chips failed, they would reject
the entire lot. They sent the astronauts
down to the facilities to remind the workers that
the astronauts' lives were in their hands. And the lab worked
with the manufacturers to increase their
quality and reliability. And this probably
ended up benefiting most computers of the future. The individual logic chips
would be placed into trays and welded together. And even with all
the inspections, sometimes there were
loose solder blobs. On Apollo 12, the
DSKY read all 8s. This indicated that
there was a short. But luckily, it dislodged
itself and didn't reappear. But there was also a short on
the abort switch for Apollo 14. And when they tapped
on it, it went away. But you really don't
want the abort switch to randomly come on when you're
trying to land in the moon, so Don Eyles told the astronauts
what they should punch into the DSKY to trick the
program that was monitoring the abort switch to think
that an import was already in progress so there was
no need to actually start the abort sequence. If short circuits or any
other hardware issue happened, the astronauts
couldn't repair it. The original plan was for
them to have a testing meter and replacement parts. However, the moisture due to
either a urine containment leak or breathing
on a Mercury flight caused a short behind a panel,
and having the Apollo capsule full of three people that were
sweating and breathing for days could really wreak
havoc on electronics. So the AGC modules
were all potted. This month moisture
couldn't get in and neither could a repairman. But that's OK
because I don't think that NASA started testing how to
solder and do repairs in space until the International
Space Station years. The memory for the
AGC was not welded. It was actually woven,
which kind of blows my mind. Both the erasable and
the fixed memories worked off the same basic
principles of electromagnetism. Magnets can store a
1 or a 0 and no power is required to keep
them in these states. This means it's
non-volatile memory. And this even survived
multiple lightning strikes during an Apollo 12 launch. Magnets are great at
representing binaries since you can have two
states, a north or a south. And if you run
current through a wire it's going to produce
a magnetic field. And this will magnetize
a ferrite core. If you flip the
direction of the current, the magnetic field will flip. The reverse is also true. By flipping the
polarity of a magnet, you will induce a current and
create an electrical pulse. There's one other trick
for this type of memory and it's called hysteresis. There's a certain
level of current that is needed to change
the polarity of the magnet. Below this current level, the
magnet will remain unchanged. And now that we know most
of the basic principles, we can take a closer look at the
magnets in the erasable memory. Each magnet represents a bit
that is either a 1 or a 0 depending on the orientation
of the magnetic field. We can select one bit
at a time by wiring in an x and y coordinate system. To read the value
of a stored bit, we need to add a
sense line that is woven through every
core in this plane. And remember, if we
flip the magnetic field, we can produce an
electrical signal. And this sense line will
pick up this induced current. This electrical pulse
is a small value but it will be amplified
at the end of the circuit. Since we want a value of
1 to indicate a pulse, we will read bits by
sending current that would drive the magnet to 0. We send the current
through both the x and the y wires that
intersect the ferrite that we want to read. The current being sent
through the x wire is half the current required
to flip the magnetic field. The y wire is sending
the other half required to overcome hysteresis. This means the other
ferrites that the x wire is routed through won't flip. You need both the x
and the y current. Reading this bit has
destroyed the data, which is why every read is
followed by a write phase. The write phase sends current
in the opposite direction. This will flip
the 0 back to a 1, but what if we had a
0 as our original bit? Well, you need to
add an inhibit line. If it was a 0, then
we can send current in the opposite direction
through the inhibit line during the write phase. The inhibit current will
cancel out half of the current that we're sending
during the write phase and it won't overcome
hysteresis and flip the magnet. If you want to write a
brand-new bit of information, then you let the read
phase flip everything to 0 and then you can choose
to either inhibit or not inhibit during the write phase. And this will either
give you a 1 or 0 depending on what
you want to store. We've been looking at
just one plane of memory. The sense and inhibit
lines are routed to all the cores on this plane. To save space, the
planes of memory are stacked on
top of each other. To reduce component
count, these x and y wires are routed in series
between all of the planes. This way you only
have one circuit to drive each x and each y. If you want to write a value to
the x3, y5 on the second plane, then you could use inhibit
lines to send current in the opposite
direction on both the first and the third planes. This means the current won't
overcome the hysteresis for the first and third
planes and those bits will remain unchanged. That's how the
erasable memory works, but there is a
read-only memory storage called core rope memory. The pattern the wires
are woven determines if the bit is a 1 or a 0. If the wire is routed through
a core, then it's a 1. If the wire is routed around
the core, then it's a 0. And just like with
the erasable memory, we need to have a sense line
to read the induced current. We don't use x and y
coordinates to isolate a core. We send an opposing current
in the inhibit lines of the two cores that
we don't want to select. Then we can send a current
through the set line. This will flip the magnetic
field only on the second core. A current will be induced
in the sense line, and since we only
have one core selected we'll know where
the pulse came from. Then we need to reset
the magnetic field for the second core. If we had isolated
core 1, we wouldn't have read any pulse
since the wire is routed outside of this first core. And we can actually
route several wires through each one of the cores. And if we isolate core 3
and send a pulse through, then we're going to get a
reading from multiple sense lines. We can only put multiple
sense lines through a core because this is read-only data. We are never
writing information. This is fixed memory
and the 0 bits are all routed outside of the cores. And over 100 sense wires could
be routed in a single core. A group of 16 sense
lines makes up a word, and this word is called a
strand inside the rope memory. These magnetic
memories are far larger in physical size than the
memories that we have today. The AGC could only store 2
kilowords of erasable memory and the fixed memory was
only 36 kilowords of storage. That's all. That's where all the programs
were, all the constants, the star and landmark charts,
and all the look-up tables was just in that 36
kilowords of memory. And this was still far more
than was originally planned. The 15-bit
instruction words were supposed to use the first
3 bits for operation codes and the last 12
bits for an address. But there were more opcodes
and memory addresses than could be represented
by those 15 bits. Programmers had to create
memory banks and special cases for the opcodes
depending on what programming mode they were in. This was an addition to the
programmers already needing to intrinsically know how
their equation works in order to utilize the math
functions, scale the values, and avoid overflows. And to top it all off,
there wasn't one AGC. We talk about the Apollo
guidance computer, but there were really many. There were two major
design versions. There was a Block
I and a Block II. And the Block II was used
on all the main missions. There was an AGC computer
on the command module and another one that
was on the lunar module. And NASA wanted them to
be as similar as possible, but there had to be differences. The LEM computer needed
to be able to be lighter and it interacted with
different hardware. The software written
for the command module was eventually called COLOSSUS
and the one for the lunar module was called LUMINARY. The basics of the
computer architecture were the same for every
flight, but Apollo missions improved upon the last ones. So the computers for each
spacecraft and mission were handmade with some
assistance from machines, but the memory was woven
and the logic modules needed to be welded. And the wiring on the back had
to be laid out in such a manner that it didn't stack up and
become too bulky in any one section. Every computer needed its own
mission profile and flight trajectory and some
programs for later missions were flown on earlier
flights to be tested. And since programs had to
be woven into the core rope memory, the code
for each mission had to be locked in a few
months prior to launch. This way there was
time to manufacture it. And when MIT originally
got the contract, they barely had
any requirements. No one, including
NASA, knew what would be required
of the computer or what it would be
capable of doing. It is amazing the
thought and care that went into each
one of these computers. The Apollo guidance
computer did everything that it was originally
asked for and so much more. It was a beautifully,
welded and woven computer. And I want to leave you with
the words of Doc Draper. He was the head of the
instrumentation lab at MIT at the time of Apollo. I can't presume to predict what
the future is going to hold, but I'm sure it's going to
be different from anything we imagined. I'm sure it's also going
to be much more extensive and we're going to do many
more tricks than anybody today imagines that we can do. And how we do this I don't know,
but the human race is certainly going to go out into the stars. I thank you very much.
