TITLE: One Giant Leap for Computing
AUTHOR: Eugene Wallingford
DATE: August 12, 2009  5:01 PM
DESC: 
-----
BODY:
<A HREF="http://www.usna.edu/Admissions/Notables/Astronauts/duke/duke.htm">
   <IMG SRC="http://www.cs.uni.edu/~wallingf/blog-images/misc/nasa-duke.jpg"
        WIDTH="250" BORDER="0"
        HSPACE="15" VSPACE="5"
        ALIGN="right"
        ALT="Charles Duke walking on the moon, Apollo 16">
</A>

Last month, in honor of the Apollo 11 mission's
fortieth anniversary,
<A HREF="http://googlecode.blogspot.com/2009/07/apollo-11-missions-40th-anniversary-one.html">
   Google Code announced</A>
the open-sourcing of code for the mission's command
and lunar modules.  Very cool indeed.  This project
creates opportunities for many people.  CS historians
can add this code to their record of computing and
can now study computing at NASA in a new way.  Grady
Booch will be proud.  He has been working for many
years on the task of preserving code and other
historic artifacts of our discipline that revolve
around software.

Software archeologists can study the code to find
patterns and architectural decisions that will help
us understand the design of software better.  What
we learn can help us do more, just as the Apollo 11
mission prepared the way for future visitors to the
moon, such as Charles Duke of Apollo 16 (pictured here).

This code could help CS educators convince a few students
to assembly language programming seriously.  This code
isn't Java or even C, folks.  Surely some young people
are still mesmerized enough by space travel that they
would want to dig in to this code?

As a person who appreciates assembly-level programming
but prefers working at a higher level, I can't help
but think that it would be fun to reverse-engineer
these programs to code at a more abstract level and
then write compilers that could produce equivalent
assembly that runs on the simulator.  The higher-level
programs created in this way would be a great way for
us to record the architecture and patterns we find in
the raw source.

Reading this code and about the project that surrounds
it, I am in awe of the scale of the programming
achievement.  For a computer scientist, this
achievement is beautiful.  I'd love to use this code
to share the excitement of computing with non-computer
scientists, but I don't know how.  It's assembly, after
all.  I'm afraid that most people would look at this
code and say, "Um, wow, very impressive" while thinking,
"Yet another example of how computer science is beyond
me."

If only those people knew that many computer scientists
feel the same way.  We are in awe.  At one level, we
feel like this is way over our heads, too.  How could
these programmers done so much with so little?  Wow.
But then we take a breath and realize that we have the
tools we need to dig in and understand how this stuff
works.  Having some training and experience, we can
step back from our awe and approach the code in a
different way.  Like a scientist.  And anyone can have
the outlook of a scientist.

When I wonder how could the programmers of the 1960s
could have done so much with so little, I feel another
emotion, too: sheepishness.  How far have we as a
discipline progressed in forty years?  Stepping back
from the sheepishness, I can see that since that time
programmers have created some astoundingly complex
systems in environments that are as harsh or harsher
than the Apollo programmers faced.  It's not fair to
glorify the past more than it deserves.

But still...  Wow.  Revisiting this project forty
years later ought to motivate all of us involved
with computer science in 2009 -- software professionals,
academics, and students -- to dream bigger dreams
and tackle more challenging projects.
-----