Howdy, Stranger!
It looks like you're new here. If you want to get involved, click one of these buttons!
Categories
In this Discussion
Week 1: COLOSSUS and LUMINARY: The Apollo 11 Guidance Computer (AGC) Code
The source code for COLOSSUS and LUMINARY: The Apollo 11 Guidance Computer (AGC) code for the command and lunar modules was digitized by Virtual AGC and MIT Museum and made available to GitHub in 2016 by Chris Garry. Previous uploads were available (Collins, 2016), but this critique uses the GitHub upload. Anyone who so desires can post about the earlier uploads and the process of making this code available. This is interesting from an archival point of view.
Specifically, we are looking at the MIT Instrumentation Lab's (later Draper Laboratory) COLOSSUS 2A code for the command module and their LUMINARY 099 code for the lunar module. (COLOSSUS 2A was aka COMANCHE 055, but for obvious reasons, we are using COLOSSUS 2A), Note that to distinguish the two programs, the command module code began with "CO" and the lunar modules code began with "LU".
The source code for COLOSSUS 2A is available at http://www.ibiblio.org/apollo/ScansForConversion/Comanche055/
The source code for LUMINARY 099 is available at http://www.ibiblio.org/apollo/ScansForConversion/Luminary099/
The code is written in the native language of the AGC's CPU, AGC Assembly Language, which GitHub observes is difficult to understand. AGC Assembly Language was originally called basic, as opposed to BASIC (which appeared in 1964). The interpreter was called yaYUL. For an early look at the AGC hardware, including how it worked and how it was constructed (with footage of the women who worked on the core rope memory), visit the 1965 MIT Science Reporter TV program coverage. This program’s demonstration of how the astronauts entered instructions into the AGC via the DSKY (display and keyboard) is also of interest in understanding the code.
Much of the early software work was done by Richard Battin, Director, Mission Development, Apollo Guidance And Navigation Program. David Hoag, Director, Apollo Guidance And Navigation Program, has provided extensive credits. He states that "Details of these programs were implemented by a team under the direction of Margaret Hamilton." (Hoag, 1976, 19)
According to Battin (as quoted in Fildes, 2009), the onboard AGC was partially begun because of concern that the Russians might disrupt ground-based communication (This may partly explain why AGC Assembly Language is difficult to decipher).
Because this critique is a part of the Gender and Programming Cultures module, Margaret Hamilton's role, as documented in the code, is of primary interest. Here are suggested approaches:
1. Review some of the code and comments and document where Margaret Hamilton is credited.
To begin with, Hamilton is credited as COLOSSUS Programming Leader in the title page for the COLOSSUS 2A code.
COLOSSUS 2A, p.1
http://www.ibiblio.org/apollo/ScansForConversion/Comanche055/0001
Margaret Hamilton is credited as COLOSSUS Programming Leader
A title page does not seem to be available for LUMNARY 099. Within the code, some segments are credited, and some are not. Documenting credited segments would be useful.
2. Critique comments from a humanist and/or gender perspective.
For instance, in LUMINARY. There is a comment that begins
"HERE IS THE PHILOSOPHY OF GUILDENSTERN:"
Tom Stoppard's play, Rosencrantz and Guildenstern Are Dead,
appeared in 1966. Is Stoppard's play referred to in this comment?
And how can this comment be interpreted in relationship to the code?
LUMINARY 099, p.800
http://www.ibiblio.org/apollo/ScansForConversion/Luminary099/0800.jpg
"HERE IS THE PHILOSOPHY OF GUILDENSTERN:"
For Instance:
LUMINARY 099, p. 801
http://www.ibiblio.org/apollo/ScansForConversion/Luminary099/0801.jpg
"TEMPORARY, I HOPE HOPE HOPE"
Is the source for this comment Desdemona in Othello?
"These are portents, but yet I hope, I hope
They do not point on me."
How can this be interpreted in relationship to the code?
Much more can be said about the AGC software; any approach or input is welcome!
When referring to specific pages, please include a citation that includes program name and the url of the page (as in the examples above).
If necessary, separate threads can be started.
Comments
Thanks for starting this, @JudyMalloy. What an incredible set of code. I did want to point to one resource people could use for seeing some commentary on this code, take a look at this Reddit discussion thread. Of course, we should also take into account the gender dynamics of Reddit.
Here's a port of a simulation of the AGC code in action.
http://svtsim.com/moonjs/agc.html
I have another question about this code:
As we think about the legacy of this code, where in the code can we see the origins of Hamilton's later work on 001Axes and Universal Systems Code?
Thanks @krystalcooper !
Based on the life and death stakes of "man-rated" software (which means human life hangs in the balance), I'm interested in the code from:
Apollo-11/Luminary099/EXECUTIVE.agc
I might start a separate code critique thread for this. But based on what I've read, a key contribution from Hamilton, meaning one that saved Apollo 11 from certain disaster, was the code that dealt with prioritizing jobs -- namely, the job of landing.
Luminary099/EXECUTIVE.agc page #1103
Based on what I can gather, one of the astronauts, Buzz Aldrin, following the system documentation, flipped a switch (activating a rendezvous radar system), caused the lander to consume computer resources necessary to land the craft on the moon, setting off the infamous 1201 and 1202 alerts. (Interesting article on all of this here.) It was the prioritization code (I believe in this file) that helped keep the software working on the higher priority job of landing.
But this code may have been written by Hal Laning:
https://www.doneyles.com/LM/Tales.html
Don Eyles writes:
Nonetheless, most of the articles I read credited Hamilton as the head software engineer with including the prioritizing and prioritizing display components.
This passage (from an article that features astronauts instead of programmers) should help us find the key code:
This code strikes me as a key component of Hamilton's legacy. But what are its central features and how did they prevent loss of life?
Although this is not about the assembly code per se, one of the fascinating things about the Apollo Guidance Computer was its reliance on core rope memory to store the code:
https://hackaday.com/2016/09/02/decoding-rediscovered-rope-memory-from-the-apollo-guidance-computer/
You can also see an image of this in the Ars Technica article Mark linked. In this piece, you can see an older woman using her textile skills to fabricate this crucial component of the hardware. According to the Wikipedia article on core rope memory, it was also known as "LOL" or "Little Old Lady" memory because of who wove the memory, another major contribution to the project by skilled women, but one that was already considered a joke at the time, as the name suggests.
A bit more:
This storage method also required that the code be bug-free because, once encoded in the rope memory, it could not be easily changed:
Thanks, @mwidner ! The women who worked on the core rope memory at Raytheon were important. And in
this 1965 MIT Science Reporter TV program
we can see how extraordinarily difficult this work was. I wonder if anyone has interviewed any of these workers.
Thank you for this, @JudyMalloy -- great framing and what compelling starting places to dive in! I'm particularly interested in the comments here.
Re: HOPE: I'm not sure about HOPE HOPE HOPE being a Desdemona / Othello reference -- as opposed to a spontaneous overflow of powerful feelings on the part of the programmer. On the one hand, the GUILDENSTERN reference is good evidence that we might expect other literary allusion, but on the other hand "I hope they do not point on me" seems like an extremely antisocial sentiment to be expressed by any coder whose work is going to be reviewed and signed off on by a whole team... unless the hope is being expressed by Apollo 11 itself, or the literary coder expected that the rest of the team wouldn't get it.
Re: GUILDENSTERN: I wonder if this is a euphemism for "pessimism", tagging the control logic as pessimistic design (i.e. assume things are going wrong and act accordingly). If so, interesting place for euphemism, because you should be able to say that directly, but perhaps you cannot say it directly (given the catastrophic possibilities if something is going wrong and everyone dies). Another possibility is that it references the opening situation of the play to gloss the binary logic of this bit of code -- Guildenstern presumes that it must come up tails eventually, yet the normal thing is it just keeps coming up heads.
Since Raytheon has been mentioned I'll chime in that they now, of course, make missiles. This foreshadows the upcoming CCSWG ethics conversation but relevant here is how these employees/contractors, by writing successful code, contributed to the success of Raythen (and other companies) that now bomb the desert.
If you ask my dad, who worked at Tandem, whose NonStop computers were in part responsible for derivatives and therefore the market crash, he'll tell you he had nothing to do with it (the market crash).
@craigdietrich
It is not the "Desert" Raytheon and others are bombing, they are and always have bombed Black and Brown bodies.
A large majority of the stack/code/design/interfaces have been and continue to be developed inside of and in support of violent and oppressive neo colonialism.
STEM programs and coding camps are by and large neo liberal recruiting tools that seek to unhinge participants from the commons as well as from historical and culture realities.
Code that does not seek to bring about new equitable political and economic space for the oppressed is code that is in service to the status quo.
All code is "Political".
"Successful" code that exist under current Open Source License schemes is often times used by oppressive states to further inflict the violence and oppression that is part and parcel to Racial Capitalism.
@fredhampton This book is coming out next month, if you haven't heard of it already: http://www.hup.harvard.edu/catalog.php?isbn=9780674728943
@craigdietrich
Thanks I will take a look.
@jeremydouglass writes:
Perhaps both. One reason to continue to look at _Othello _ re this code comment:
is that we are in the tense lunar landing section of the code.
Desdemona's similar words are spoken in the moments proceeding her death.
And the preceding pages of the code:
deal with throttle control.
I could have cited more of the comment, as follows:
@craigdietrich @fredhampton Your criticism of Raytheon's missile systems is valid. It would be of interest to know what else (besides the AGC) they were working on the 1960's.
We could also look at whether or not the women who worked on the core rope memory were unionized. However, Raytheon was the hardware contractor, not the software contractor.
Yeah, the "reading" of Ada Lovelace's program on Reddit is interesting, if thoroughly dismissive in ways that are pretty typical for readings that obscured her contribution in favor of Babbage.
https://www.reddit.com/r/AskHistorians/comments/5ohhcb/was_ada_lovelaces_first_ever_recognized_program/
The other sections I'd like to pursue -- again because they are related to the aspect of the code that is generally attributed to Hamilton as an innovation -- are:
Apollo-11/Comanche055/DISPLAY_INTERFACE_ROUTINES.agc
Apollo-11/Luminary099/DISPLAY_INTERFACE_ROUTINES.agc
These are the sections that deal with the priority display.
Here's an excerpt from the documentation of the Comanche software (by the way, any comments on the choice of Comanche?):
Again, these Priority Display's are central to what kept this mission on track and are central to Hamilton's contribution. What do we make of the code that drives them?
There's an assembly language overview here: https://www.ibiblio.org/apollo/assembly_language_manual.html
Reading up on the assembly language tells us a lot about the relationship between the programmers and the hardware designers. So with the caveat that I don't have outside background knowledge:
The language and the machine interface generally is a huge mess. It's clear that a preliminary set of requirements was determined before hardly any development had taken place, likely by people other than the actual team of programmers. A 12-bit address scheme was chosen, giving 4k of memory. This left 3 bits for the instruction, which would have given only 8 possible instructions.
From this starting point, the software began to be developed. The developers needed all kinds of features. It's clear that a complete redesign of the hardware was off the table (whether for temporal or political reasons), and consequently, as needs arose, they were added to the machine in an ad hoc basis. There are a few registers that perform an operation on whatever data is stored in them. After 3 or 4 of these, I'm guessing, the hardware designers capitulated to an extended form of instruction coding, i.e. an instruction which tells the CPU that the next instruction is to be interpreted via the extended instruction set. Finally, the 4k of addressable memory wasn't sufficient, so another register was added to provide for bank switching.
At some point somebody realized that they could actually save memory at the expense of a little speed if they wrote an interpreter and basically had the instructions executed in a virtual machine. I'm definitely curious how this came about; at this time using interpreted language in a VM-like way was pretty innovative.
There's two things I would note about this story:
First, rather than having the hardware invented by one team and the software by another, there was clearly a lot of back-and-forth. This is very unusual in the history of computing.
Second, this whole thing was a very social process. Whether Hamilton wrote any particular line of code or not, I think it's safe to count her as fairly involved. I haven't looked at much of the github yet, but my impression is not that of a system written by individual programmers managing isolated pieces of code.
Thank you @ebuswell for pointing us to that assembly manual.
I wanted to point to another section of the code that might interest some of participants, especially looking ahead to the Race and Code week.
Here's a section from the Master Ignition Routine called Burn_Baby_Burn
Apollo-11/Luminary099/BURN_BABY_BURN--MASTER_IGNITION_ROUTINE.agc
In that code we find a note in the header comments that was obviously added after the original code was written (which we should take into account regarding all of these header comments at least) it says:
Page 731
It makes me think of Tara McPherson's article on how Unix developed in the midst of the Civil Rights movement in America.
What do you make of this encoding of a racially charged catch phrase, linked to such a tumultuous set of social events? How does this act, the very naming of this file, connect the space race with this race space, where an America was in flames because of other dreams deferred and denied? How does that affect the way we read this section of the code (which is credited to Don Eyles and Peter Adler, btw), as I have noted here.
There's a certain humorous tone I'm finding over and over again throughout the comments. Humor that seems to consistently undercut the grandiosity of both the function and the way the function is programmed. Some examples:
@markcmarino's example in the other thread of "HONI SOIT QUI MAL Y PENSE" ("May he be shamed who thinks badly of it")
The name of the user interface file is "PINBALL GAME BUTTONS AND LIGHTS," and the whole system is referred to as PINBALL.
That file starts out with a quote making fun of the noun and verb user interface:
"IT WILL BE PROVED TO THY FACE THAT THOU HAST MEN ABOUT THEE THAT
USUALLY TALK OF A NOUN AND A VERB, AND SUCH ABOMINABLE WORDS AS NO
CHRISTIAN EAR CAN ENDURE TO HEAR."
HENRY 6, ACT 2, SCENE 4
In light of this, I'm guessing that @JudyMalloy is right about the Ophelia reference, although I don't know what it means without finding the "STOPRATE" subroutine and seeing what that does.
Guildenstern, I'm guessing, is a reference to Hamlet, rather than the things that came after it. Maybe to:
"But we both obey,
And here give up ourselves, in the full bent
To lay our service freely at your feet,
To be commanded."
A quick google search for P66 and P67 shows me that they are the modes for manual guidance during the final phase of the landing procedure. According to the comment, when an astronaut starting using either the manual throttle or altitude controls, the computer would automatically go into the correct mode, without the astronaut first having to tell the machine directly to go into that mode, as is normally done. So basically, the program is anticipating and executing a mode switch that was wanted but not actually called for, i.e. being sycophantic.
Just briefly: there is of course a convoluted relationship between all this and gender. The de-feminization of computing goes hand in hand with making computing into a Serious Thing that Men do. This code itself may have had to do with that. There's a story elsewhere (I didn't look up the source, but it's on Hamilton's Wikipedia page) that Hamilton invented the term "software engineer," and by the end of the Apollo missions the other (hardware) engineers had come about to recognize that, indeed, programming was a type of engineering. So this may be transitional code, written from both a programming-is-(playfully)-translating-equations-from-the-Big-Men attitude, and programming-is-serious-work-not-for-women-no attitude.
The Locus of the Nasa/Apollo programs is grounded in the violence and oppression of a technology enabled militarized racial capitalism.
We examine the code in an effort to understanding gender and programming culture; while over looking the possibility that the racial capitalist frame work that the code was created to reenforce, seeks to coop and commoditize race and gender in it’s ever pressing violent thirst for life/earth/bodies.
Here it is important to note that commodification is never an empty proposition. In using the term “commodification” I’am implying a forced/coerced movement away from emancipatory identifiers and into the Racial Capital regime.
@markcmarino asks:
There are macho issues with Adler and Eyles' questionable appropriation of a black Disk jockey's words spoken in a very different context. And as you suggest, given the large amount of funding for space exploration, their appropriation of "Burn, Baby, Burn" is very insensitive.
The reference is to:
The word "burn" is heavily used in space technology
(Although, this date may be later than the actual writing/naming of the code),
the date on page 731 is July 14, 1969
Bastille Day.
Only a few tense days before the actual moon walk.
Nevertheless, the appropriation of "BURN, BABY, BURN" is problematical.
Re: GUILDENSTERN: I really like @ebuswell 's proposal that this might be (or also be) a reference to the original Hamlet. However, that quote doesn't seem like a perfect match to me. The strange thing about "To lay our service freely at your feet, / To be commanded" is that it is a good metaphor for almost all imperative programming in general -- almost all of the code is there to be commanded, and there isn't much about it that is specific to anticipating the needs of a user during a particular subroutine.
The flipping of the coins in Stoppard's Rosencrantz and Guildenstern Are Dead is promising compared to the code flipping between P67 and P66, but perhaps moreso the
PHILOSOPHY OFreally sounds like a Stoppard reference -- I would guess that people discussing Hamlet pre-Stoppard would be really surprised to hear someone say that Guildenstern has a "philosophy." Earlier I mentioned pessimism (vs. optimism) in general as a possibility, but the scene description head note from Act 1 might be another possible reference point:I wrote:
Now, I just came across a post on StackExchange by Karl Nicholas that references a documentary (possibly this one: Apollo 11: The Untold Story (2006)) that attributes the priority-scheduling to John 'Jack' Garman.
So if our larger question is about who gets the credit, it seems as though credit is fairly distributed. Now whether that's appropriate or not, or effacing Hamilton's contribution, is another question.
That post also offers some other useful links to help us.
If credit is being handed out then we should make sure (as a society or as book authors or whatever) that credit goes both ways. For example, if any code or production led to the advancement of missiles systems or the companies that produce them.
I know I'm swimming upstream on this; it'd require a paradigm shift to start blaming employees for the problems of their corporations beyond the upper management (though did anyone go to jail from Enron)? Think Union Carbide.
So @craigdietrich and @fredhampton, I don't want to miss your larger critique of NASA software leading to military software and weapons systems -- although I don't think Hamilton and her team, based on their accounts, had any of this intentionally in mind.
But let's take it a bit more concretely, if we read this code through the lens of later weapons systems of the C4ISR order (Command, Control, Communications, Computers, Intelligence, Surveillance and Reconnaissance), what do you notice?
What specific lines of code or modules do you read differently given that approach?
(I'm not taking issue, just asking you to now read the code through that lens. I suspect most of the code would read differently.)
Re: Hamilton's legacy, I just came across this passage in an article from 1984 entitled "Computers in the Military and Space Sciences" by Brick, Draper, & Caulfield.
Also from that same article, a claim that adds fuel to a particular fire in this thread:
@markcmarino writes:
With this and other entries in this week's threads (importantly the credit on the top page of COLOSSUS 2A, as well as Hoag, 1976, since he was Director of the Apollo Guidance and Navigation Program), we have verified Margaret Hamilton's core role as programming director.
It is also useful to have a few examples of her credits within the software packages, such as
For the routines in this section, modifications are specifically credited to other team members here:
It would be of interest to know the names of all 350 of the team members -- for this forum, to identify the women, but all the team members should be credited somewhere. This is probably beyond the scope of CCSWG. Perhaps it has been done elsewhere?
Note that COLOSSUS 2A is aka COMANCHE 055. See http://www.ibiblio.org/apollo/ScansForConversion/Comanche055/0001.jpg for verification of this.
To avoid native appropriation, I use COLOSSUS 2A .
My point in raising the question of credit is not to challenge Hamilton's role in producing the code, but to pursue the question: Why isn't she more well known?
I was speculating that one reason was that historically people have attributed the code (or significant parts of it) to other people. If certain team members have taken "credit" for parts of the code that might be one -- but not the entire reason. Even if she engineered the code and did not write one line of it, I would still think we could attribute the software to her. (For a broad example, Steve Jobs gets credit for the iPhone and iPad even though he did not design the hardware.) But a harder task offhand (without a full lit review) is to measure someone's reputation (which is why I thought the Wikipedia talk page might be a good place to look first.
So my question is: to what extent have people attributed this software to her? And if it wasn't to whom was it attributed? The background question is why have women who have developed software disappeared from accounts of computational history? I see this as complementary to our recovery mission.
But yes, let's see if we can determine what other women were working on this project.
By the way, here's the list of verbs and nouns that the team designed for the astronauts to use.
“How do you take a pilot, put him in a spacecraft, and have him talk to a computer?”
----- Dave Scott, Apollo 15 Commander
For this week’s code critique I am interested in how the gendering of code occurs at the level of conventions of etiquette typically associated with human conversation. The two-digit code of “50,” for instance, represents the extended verb “PLEASE PERFORM”; it was commonly used to initiate an operation.
The vast majority of verb operations in Colossus 2A do not begin with “please.” For instance, codes beginning with the phrase “request” do not include the addition of “please.” The inclusion of “please” appears reserved for initiating operations. While “please” only comes up several times within the documentation of the source code for Colossus 2A, it also comes up in notes external to the code itself: “Please report any deficiencies in this list to John Sutherland.” Here we have “please” operations both for the on-board computer, and for a human.
My questions about the inclusion of “please” require more research to come up with sufficient answers (research which I would love to do). Regardless, asking about the human-ness of the machine (whose “gender” will inevitably be complicated via the types of commands given) can help contribute to avenues for further research into the Apollo code.
Apologies if the “please” question has been broached before; but I have yet to find any documentation of “please” in particular.
Thanks @Kir
What a lovely question.
2001 A Space Odyssey came out in 1968.
Here is a clip on Youtube
I love this "please" meditation, @Kir . I'll be interested to see what we can find.
The list of Please instances from the verbs.
Apollo-11/Comanche055/EXTENDED_VERBS.agc
Please Perform Engine-Fail is the most alarming one to me. Very Kubrick. (That can't mean what I think it does.) Perhaps for space reasons, the "please" does not appear for all in the chart of verbs and nouns.
But I think my favorite of the Please comments come from
Apollo-11/Luminary099/THE_LUNAR_LANDING.agc
Which comes shortly before:
A bit further on in the same file:
Clearly they had sense of humor, even given lives in the balance.
My sense is that there is a subtext of issues between the astronauts and the coders underlying some of the commented code in the AGC.
David Mindell begins Digital Apollo (MIT Press, 2011) with histories of how computer-mediated flight control was introduced into a heroic male pilot culture and the issues that arose, including a complete chapter on the X-15. These issues are threaded thoughout Digital Apollo.
Given that 2001, A Space Odyssey was released the year before Apollo 11, that film could be considered as addressing this issue in space exploration of the era
It would also be of interest to look at "please" as a class identifier in Gilbert and Sullivan's HMS class-shifting H.M.S. Pinafore. This is contingent with @Kir 's analysis of "please" in terms of power. Gilbert and Sullivan's works were, at least in the 1950's, widely performed in the Boston area and had something of a cult following.
@markcmarino
Disturbingly but not unexpectedly, in addition to the astronaut vs computer programmer issue, in this comment and in other comments, there may also be a subtext of a woman director in the male MIT IL culture,
See the line to the effect of "I put the silly thing in reverse" in
A Witch's Tangled Hare (1959 Warner Brothers Looney Tunes cartoon, which you can watch here
Yikes!
Kudos to Margaret Hamilton for working so well in this environment!
The reference to the apartment not being 2B "(2B or not 2B)" is also of interest given, the CM code being COLOSSUS 2A
I'd be willing to bet that 'PLEASE' has to do with the order of operations, indicating that what you just executed may run but has a chance of not running, no or later, due to other, more important, operations in the queue.
Thanks. @craigdietrich That makes sense and also works with possible "Open the Pod Bay doors, please. Hal" origins of "please", since it cannot be assumed that HAL will open the pod bay door.
Note (inserted on Feb 3, 2018 ):
Given that Hal Laning was a major early programmer on the AGC code, the question of why the computer in 2001 A Space Odyssey was called HAL is of interest. And, as regards "please", it is even possible that Kubrick took it from the AGC code, rather than vice versa.
This may be an aside, but this reminds me of the parody of PLEASE as a programming keyword in the programming language ("Compiler Language With No Pronounceable Acronym"), a weird language.
From the Wikipedia write-up of INTERCAL Control Structures:
From the Progropedia INTERCAL page:
I particularly like this detail: the error messages state that it is the programmer (and not the program) that is insufficiently or overly polite. This lines up with the idea of a program as dialog between programmer and machine.
It also connects back to @JudyMalloy's example of "please" in Kubrick's 2001 exchange between HAL and Dave Bowman.
In Clarke's original text for 2001, there are a several interesting "please" interactions. Here is a key one between Dave Bowman and HAL (emphasis mine).
In Clarke's original text, the crucial conflict scene is not the film's "Open the Pod Bay doors, please. Hal" scene -- it is instead a fight over the hibernation controls to wake crew members who will replace the dead Frank Poole. That original scene is also a "please" argument, although it plays out differently. The chapter is titled "Dialogue with Hal":
By contrast, in both the book and the film, as Bowman disconnects HALS computational brain we hear HAL argue in the imperative ("Stop") and in descriptive terms ("You are destroying my mind. Don't you understand?") without ever once uttering the word "please."
@ebuswell's suggestion that the Guildenstern reference may be coming from Shakespeare's Hamlet rather than Tom Stoppard's play, seems plausible. According to Wikipedia, Stoppard's previewed for the first time at the Edinburgh Fringe Festival in 1966, the same year that Hamilton is credited with her contribution to this code base. Unless these comments were added much later, it seems somewhat unlikely that Tom Stoppard's play would have reached the NASA team at the time of this project's creation.
I also wonder, given we don't have a list of everyone involved in the project (and Hamilton is actually credited more than other members of the team), whether Guildenstern could be another team member, one with a particularly philosophical manner? Given the number of other playful literary and theatrical references in the code comments, I would not assume this is the case. However, I would also not assume it's not the case.
Would it be possible/at all reasonable to reach out directly to Margaret Hamilton with some of these questions? Her company, Hamilton Technologies has a website, updated in 2018, with contact info: http://www.htius.com/ It seems like it could contribute well to the archive of her work to reach out for some commentary on her own code.
I really like @kir 's comment about reading into the "etiquette" of the code and the use of "please." I wonder if this analysis can be extended to a more broad reading of gendered manners in code, at NASA and other institutions.
In fact, leaving comments in the code is in itself a kind of etiquette, which takes place in a social context, recognizing certain power relationships. I wonder how many of these quirky and humorous snippets of comments were left by men and how many by Hamilton or other women engineers. I find that programming humor (in places such as Reddit's programming humor subreddit) is super-bro-y, and leaving cheeky comments in a shared code base takes a certain presumptuousness that not every developer may feel entitled to. This kind of humor also gives hints to the culture of an organization, and may reveal the kind of gender dynamics/expectations that exist there. I think humor provides a great window for understanding and practicing critical code.
2 other files we might want to turn our attention to are:
Apollo-11/Comanche055/SERVICER207.agc
which has Hamilton's name on it and
Apollo-11/Comanche055/ERASABLE_ASSIGNMENTS.agc, which deals with priority displays, one of her main design contributions.
Not only a dialog between programmer and machine, but a relationship with really interesting power dynamics. The programmer doesn't tell the machine what to do -- it asks, and in INTERCAL, sometimes even begs.
One of the important things we have established in this code critique is that the comments in the AGC code are a rich source for humanities scholars in areas including 1960's culture and politics; issues between astronauts and software programmers/engineers; issues, including gender, in software engineering environments; the culture of the MIT IL; and of course the code itself and the importance of Margaret Hamilton, herself in the creation of this code.
Thanks @markcmarino @jeremydouglass @krystalcooper @mwidner @craigdietrich @fredhampton @rogerwhitson @ebuswell @Kir @a11ykat @brandeeeaster and anyone else who responded here!
Although the focus of CCSWG18 will soon will shift to Week2 and Week3 themes, this code critique will continue in the background, and more discussion is welcome.
Thank you @JudyMalloy for your leadership on this thread.
We've had quite a few additions to our list of women programmers who work or have worked in space exploration. Here are a few of the ones mentioned since we started this thread. Not all are from the Apollo era, but it seemed more useful to build as full a list as possible.
Some of the people we've found:
More details to come, but I wanted to include a few of the additions here.
I am also curious about how to critically read Adler and Eyles' retrospective explanations of BURN_BABY_BURN--MASTER_IGNITION_ROUTINE. A few posts up, @markcmarino quoted Eyles from 2005 and Adler made an even more direct reference to the Watts Rebellion in 1998:
My first impresion is that Adler and Eyles offered these explanations with an awareness of themselves as historical actors. By referencing anti-war demonstrations and the Civil Rights Movement, they located their work within the mythological 1960s found in dramas like "The '60s" TV series from 1999. Would their explanations have been different in 1968? Or 1970?
Yet, the voices and memories of programmers are invaluable resources for interpreting old code. So what else we can we learn from reading their code alongside their recollections? As @a11ykat notes, humorous comments might be clues about the organizational culture within which the code was written.
Perhaps Eyles' reference to the Magnificent Montague was a reflection of team's work environment. The MIT Science Reporter piece showed a staid classroom with charts and chalkboards but maybe this was cleaned up for TV. Do we have access to any candid documentation of the workspace? Snapshots from the employees? Were they listening to the radio while working on the AGC? Was this code written to a soundtrack of soul singles and news bulletins?
(These questions are also inspired by the many references to heavy metal in David Kushner's biography of id Software.)
I would love to collect some good models for combining the voices and memories of individual programmers with critical readings of historical code. Anyone have favorite citations to share?
That's a good point. I wonder what the earliest reference to the name of Burn_Baby_Burn is, which might speak to a larger question.
Whom did they expect to read this code? What kind of audience did they anticipate, knowing it was a government project but not knowing the future of open access, code literacies (if we can call it that), and even CCS?
On the theme of self-aware historical actors, the Apollo 11 code was amended with code notes in 2009 to make it explicit that "BURN, BABY, BURN" was a Magnificent Montague quote. The source was a story told by developer Don Eyles as "the get-together of the AGC developers celebrating the 40th anniversary of the first moonwalk."
A 2016 Quartz writeup on a newly available Github repository of the Apollo 11 code muddled the difference between these 40th anniversary comments and the original code. This missing distinction was then incorrectly cited by the Magnificent Montague Wikipedia page, which falsely stated that Montague "was referenced, by name, in the Apollo 11 software code that took America to the moon in the mid 1960s."*
*Emphasis mine; and now corrected five minutes ago by yrs. truly.
Thanks, @jeremydouglass As the Wikipedia mistake points out, it is good to look at the original version, before or in conjunction with the annotated version. This is why in the intro, I directed folks to the scanned original version:
However, as @driscoll notes:
In each comment it would be good to cite the original version (and the url for the page), and then, if the annotated version is used, to also cite the url for the portion of that version that is under discussion . Yes, I know this takes time, so no problem if this is not done in this informal discussion -- just something we should consider, as this conversation continues.
Also, importantly @markcmarino asks
This applies also to artists and writers who have given their work to archives. Dene Grigar actually went to Duke and in my archives, she read my notebook for Uncle Roger . There, in my handwritten pages from 1986, she discovered some information that purposefully I did not disclose to readers in the work itself. It never occurred to me that anyone would actually read that notebook, and I was surprised when in Traversals I read what she (a great researcher in archives!) had discovered. Thus, I have been wondering what Mark is wondering. And we should be aware of this, as we trespass on this fascinating code.
I agree that we should standardized our code bank. However, since Critical Code Studies also looks at how code circulates and since many have accessed this later annotated code, it becomes another important document, worthy of analysis in comparison to the original. For instance, why was this explanation added to this code? Do they explain the name or try to prevent a misinterpretation of the name?
Something about this inquiry, especially @driscoll's comments made me wonder about Eyles' later recollection, appended to this code.
I went to search for that phrase, "Burn, Baby, Burn" on NASA's history page, and it comes up in a few other Apollo missions. Here are some examples. In the first one, the phrase was mentioned by Eugene Cernan (aka The Last Man on the Moon) in the debriefing afterwards but attributed to Day 1.
https://history.nasa.gov/afj/ap10fj/as10-day1-pt4-tli-docking.html
We hear the phrase again on Apollo 10's return trip. Again, by Cernan.
https://history.nasa.gov/afj/ap10fj/as10-day6-pt29-tei.html
It does make me wonder if he only used it this time. Then we hear Richard Gordon say it on Day 4 of Apollo 12's mission. (I've put a note about the burn they are referring to below).
https://history.nasa.gov/afj/ap12fj/11day4_lunar_orbit_2_5.html
Burn, baby, burn seems to mark time during this burn. And three year's later with Cernan back on the mission, he says his catch phrase (which is also the name of a chapter in his book about his space travel) again.
https://history.nasa.gov/afj/ap17fj/01_day01_launch.html
I'm particularly interested in those Apollo 10 comments that were in the confidential debriefing. Now, Apollo 11 was only a few months later, but it was interesting to see Cernan's use of this phrase on that previous mission.
While I am not calling Eyles' account of the origin of the phrase into question, I find it interesting that this was a phrase Cernan used more than once, and possibly more than once during Apollo 10 and conceivably in the preparations for it, since it seems to mark time during the ullage burn procedure.
** Small note on ullage motors copied from Wikipedia:
Thanks @markcmarino
Particularly important is Cernan's use of the phase.
As you point out, we don't know if "Burn, Baby, Burn" appeared first in the AGC code. It might have been in general use among the astronauts, who according to Mindell (MIndell, (2011), spent time in person at the MIT IL, as well as with the code.
I think we should look at Marvin X's 1965 poem
Burn, Baby, Burn
Of particular interest is Marvin X's phase:
"Boommm...2 honkeys gone"
More Information about Marvin X is available on the Conference Program for Black Arts Movement Conference Program at UC Merced, Feb 28 thru March 2, 2014 at
https://blackbirdpressnews.blogspot.com/2014/02/black-arts-movement-conference-program.html
Wow, excellent find, @JudyMalloy,
Just to clarify my point, I don't have questions about whether or not Burn, Baby, Burn was in the code originally, since it names the Master Ignition routine/file and BURNBABY shows up elsewhere in the code. (Although, you might be saying we don't know exactly when that code is written, which is key.) Was this connection to Magnificent Montague the only explanation? Or an explanation that evolved over the 40 years since? Even if Montague was one source, his use of the phrase, as you've shown, may just be part of the story. And even if the DJ's catch phrase was Eyles' reference, that doesn't lock down it's meaning any more than it would in other forms of symbolic communication from poetry to film.
@JudyMalloy -- re:
Very true -- perhaps the astronauts had a way of talking that the coders picked up and that then made its way into the code... or perhaps the coders wrote code, and that code then made its way into astronaut speech.... OR perhaps the coders had a way of talking that the astronauts picked up, and that the coders in parallel put into their code. We can look for the earliest known instance in an attempt to resolve the question, but it may not be resolvable. Even at the time, the vectors of linguistic transmission might have been unclear to those involved.
To me this recalls some of the pioneering work that Mary Ann Buckles did on ADVENT in her ~1980-85 dissertation, and in particular her approach to communal code writing and use (in ARPANET-based interactive fiction) as "folk art," which could be thought of in ways similar to the long history of folktales and other oral traditions.
Buckles, Mary Ann. "Interactive Fiction: The Computer Storygame 'Adventure'." Ph.D. Thesis. U. Cal at San Diego, 1985.
@jeremydouglass says:
Yes, the analogy to burning cars in the Watts Riots and burnt astronauts in space vehicles is clear without Marvin X's poem. Nevertheless -- as we look at the cultural and political environment of the AGC code -- Marvin X's phrasing and use of the word "boommm..." is trenchant. And despite Eyles' attribution to Montague, the unseen chain of allusions could have also included Marvin X's poem.
The reference is to:
Precisely who was the master -- the astronauts or the coders -- was an area of contention. (Mindell, 2011, pp.158-160). However, given the context of privileged people with good jobs, I continue to think the appropriation of "Burn,Baby,Burn" is problematical, even if not meant to go beyond their circle.
I'd also like to note that at some facilities, NASA employees and NASA contractor employees were more diverse than would be expected in this era. In the year of 1969, my immediate superior at Ball Aerospace was the Chicano writer José Antonio Villarreal, who, at the same time, was writing The Fifth Horseman.
Regardless of where the phrase came from, or how it entered the code, I'm wondering how it makes us perceive the code differently? How do we perceive the operations of the code differently because of this name?
Can I push us into the assembly? How does the naming impact the way we read the operations and how the algorithms have been implemented?
Mark asks:
In
Mindell, David A. Digital Apollo: Human and Machine in Spaceflight. Cambridge, MA: MIT Press, 2011.
(which I was not able to get in time for the beginning of this code critique),
chapter 8 "Designing a Landing" (pp 181-215), contains a section on "Landing as a System", In this section, five major subsystems that defined the landing are set forth.
They are:
the LM descent engine (Descent Propulsion System. DPS)
the Landing Radar
Communications (antenas,etc.)
**The Guidance Computer **(which controlled these systems)
The Humans (the astronauts)
My sense is that it is helpful to look more closely at how the landing worked as a whole before diving into the code. Knowing exactly what it was controlling should help in reverse engineering (so to speak
) the assembly code. However, I have not yet finished the book.
From my POV, Mindell is useful on the engineering aspects of the project, with which I'm less familiar, as well as on the astronauts vs programmers issues, which are probably a subtext of the code. However, Mindell's documentation of the AGC source code itself is not as useful. Appallingly, Margaret Hamilton is mentioned only 3 times and none of these mentions are in depth. She is not the only AGC programmer who is slighted in this book. George Cherry (who I think, under Hamilton, was Project Leader of the LM code), is mentioned in only one sentence.
Contingently, it would be of interest to know why the most interesting comments are in the LM code. Did Hamilton clean up the comments before officially submitting COLASSUS 2A? Was Luminary 099 less officially submitted, or was George Cherry (if it was he who put together the LM code) less concerned about the comments. Or were the "allusive" comments created by programmers (Eyles?) whose work was perhaps mainly on the LM code?
Actually, I'm wondering about these file names. I think the code would have been assembled from a stack of standard 80 column punch cards, yes? And presumably when these cards were contained in a "file," that file was quite literal. How would these be named? Does anybody know about the material filing and organizational practices?
At the risk of dwelling too long on the genealogy of "Burn, baby, burn", I have to mention the return of the phrase in 1977 as the hook to "Disco Inferno" by the Trammps. Not only was "Disco Inferno" a huge hit on the radio and in clubs, it also scored one of the most memorable dance sequences in Saturday Night Fever (that funhouse mirror reflection of emerging crises in American masculinity!). So, when I read "burn, baby, burn", I will always hear "...disco inferno!" and picture Travolta's hips.
The thing that is keeping me hooked on this archival puzzle is how it highlights the interstitial quality of code. Neither an official design document, nor the meticulously woven rope memory, this code seems to give us a glimpse into the working culture of Margaret Hamilton's team. Did the uncertain, transitory status of code allow for a bit more playfulness than other types of writing or making? Did it feel comparably informal, such that traces of workplace humor seeped in? Do you suppose any of the programmers were uncomfortable to learn that their code would be made public?
(NB: the Saturday Night Fever soundtrack LP features a ripping 10+ minute mix by Tom Moulton.)
@driscoll asks:
This is a good question. In response, I replayed Matt Kirschenbaum's University of Pennsylvania lecture -- in the midst of which he uses three versions in three different collections to look at changes I made in an early work --
When I first played this talk, my response was dismay. Wasting Time was published on a disk accompanying a literary magazine and was for a literary magazine audience -- not the general public. Furthermore, in 1992, no one read electronic literature code, or looked at the comment Matt displays on a big screen, or used three different disks to track an elit writer's changes.
But there is nothing I can do to stop archivists, and I have changed my mind about the worth of the archival process. Today I replayed Matt's talk and instead of dismay, I was awed by his work as an archivist.
Contingently, @ebuswell says:
The process was probably something like this (but should be verified):
Programs were written by hand, probably on IBM coding forms.
Yes, they were keypunched on 80 col IBM punch cards,
batched and sent to a Honeywell 1800 and later an IBM 360.
When the whole was working, they were sent to Raytheon
to be hardwired in the core rope memory process.
Here, I think only an archivist could trace changes from the original handwritten file name, to the final source code. But it is a good question!
Here is Mindell's description of running the subroutine BURNBABY:
Excellent find, Judy,
I wanted to bring in over here some of what I've introduced in a separate thread on AXES or Universal Systems Language.
Some of what we've been talking about is Hamilton's legacy and how it is extended or obscured by accounts of the creation of the code. Around the release of the code, I found a series of articles that celebrate her contributions, reprinting the famous picture of a young scientist (Hamilton) next to a stack of code. But I've found other threads that celebrate Don Eyles who was a mere lad of 23. Others celebrate Hal Laning as an innovator, especially of the multi-processing aspects of this code.
But Hamilton's experience led her to develop AXES or Universal Systems Language.
Again, there's more on the dedicated thread about AXES, but since in articles about this meta language, or what Todd Millstein has identified as a "modeling language," Hamilton and her co-authors (and perhaps I'm doing a bit of obscuring here) repeatedly (as in each article) reference her experience on Apollo 11, it seems relevant to then try to read the code against this later development of her work on software engineering, error handling, and multi-task prioritization, among other developments.
How does our reading of this modeling language shape the way we then read her code, especially sections that deal with task and display prioritization.
A bigger question is how does CCS read these diagrammatical software models?
Thanks, @markcmarino
I think you have already referenced
Hamilton, Margret H. and William R. Hackler. "Universal Systems Language: Lessons Learned from the Apollo". Hamilton Technologies, December, 2008 pp 34-43,
Available at http://www.htius.com/Articles/r12ham.pdf
which explains the USL notational systems
As you point out, USL points to definitions and languages of software engineering and how Hamilton implemented software engineering on the AGC code project. This was one the major topics raised in the Gendering the Apollo 11 Onboard In-Flight Software: topic -- where time has not permitted the thorough look at software engineering that I intended.
From my POV, I'm not sure that we have explored the AGC software itself thoroughly enough to look at it through this lens -- but we probably never will. We are blue-skying here. It is what we often do on CCSWG. This has value when approaching complex systems!
I hear you, @JudyMalloy! There are so many compelling questions and artifacts in this thread. It's like peaking into a telescope and seeing the whole galaxy.
Yes, @JudyMalloy, I agree that we are still at the very early stages of our investigation and some of what we have to do early on is point to all the different points of entry.
But my thinking is that we can try to read the code in light of Hamilton's chief contributions and foci of her later research (error prevention and systems engineering, and multiprocess task prioritization) and through the related developments of Apollo 11 that are attributed to her and her team (priority display, priority task management, error handling). (I apologize for repeating myself here a bit. Perhaps this is a kind of summary of points I'm trying to argue.) So we can look at what this software does and how it does it in light of its legacy, innovations, and contributions against the backdrop of its history and as an outgrowth of a development team with a collaborative set of relationships (think about our gender conversation here).
I'm also trying to get us to move beyond the names of functions and files and into the architecture of the code, the shape of its construction, et cetera, which again seems fitting since one of the mothers of software engineering was are original entry into this exploration.
Thanks @markcmarino !
When I look at the images in Hamilton and Hackler, (2008), I keep thinking of the array of hypertextual arrow-indicated links and other forms of inventive notation which I saw at the UC Berkeley music library when I opened the string-tied manilla folder that housed Pierre Boulez's Troisième sonate pour piano, Formant 3: "Constellation -- Miroir". (London, Universal Edition, 1963)
On google, I can't pull up the exact page I'm referring to, but since we are looking at the cultural environment, taking a look at Boulez (and Cage, etc.) notation, that occurred in the AGC software era, is an interesting path. (although, there probably isn't a direct connection)
@markcmarino asks:
To add to the Boulez notation I brought up in my last post, I note in William R. Hackler's bio (Hamilton and Hackler, 2008) that Hackler studied with composer Mertin Brown (who did have connections with Cage).
Note that in Hamilton and Hackler (2008), MH's bio states that "She received an
AB in mathematics and philosophy from Earlham College." This is the first time I've seen philosophy mentioned in her bio.
In reviewing the work we have done in this thread, I note that it would have been good to include a linked pointer to Week 1: Gendering the Apollo 11 Onboard In-Flight Software
I thought that the Vanilla conferencing software would keep all the Week 1 threads together, but instead, because the order of threads is determined by posting, Week 1 threads are now separated on the main board. So, since the information in the Gendering thread was meant to be read in conjunction with the actual code critique -- as an addendum -- here is the introduction to the Gendering the Apollo 11 Onboard In-Flight Software thread:
To respond to these questions, it would probably good to go to Week 1: Gendering the Apollo 11 Onboard In-Flight Software and respond in that topic itself. But given the informality here, replying wherever you want is good!
onward.....
So, I've been tracking down some other literature about the architecture of this code to help our investigation. I've Found Frank O'Brien's The Apollo Guidance Computer Architecture and Operation to be very useful. Incidentally, it does not mention Hamilton or the other coders, as far as I can tell.
It particularly discusses the priority-based multiprocessor system that we see in the AGC. One of the sections he draws attention to is the prioritization code in Luminary099/EXECUTIVE.AGC
(Page 1107)
http://www.ibiblio.org/apollo/listings/Luminary099/EXECUTIVE.agc.html
We should also take at CHANGEJOB routine as a major feature of this prioritization.
What I don't know is how popular this architecture would have been or where it might have been drawn from. It does seem to have been a crucial feature in the design of Apollo 11's software.
I'd like to look a little deeper into how this section operates, again reflecting on Hamilton's team's contribution.
A little translation from the manual:
Thanks, @markcmarino
The following reference -- that lists notes and memos from the programmers who worked on the AGC software -- is helpful if we want to identify full names of programmers whom we've found in the code. The titles of their notes and memos are also of interest.
And here, based on Hoag (1976), is a hopefully relatively accurate chart of leaders of the AGC software project in the time of Apollo11.
Finally - another woman who worked on Apollo 11 software!
She is credited as D. Densmore in the list of memos above.
If you page down on this page in Don Eyles' website
You can also see a photograph of her while on a walk with Eyles
http://sunburstandluminary.com/PIX/DDinVines@506x330.jpg
Also, I should note that the chart above is a simple representation of the MIT IL organizational structure at about the time of COLOSSUS 2A and LUMINARY 099 and is not official. Official charts vary radically. Also the chart above should include YUL programmer, Hugh Blair-Smith.
Fantastic find, @JudyMalloy!
In Digital Apollo, Mindell (2011) opens the chapter on "Programs and People" in this way:
This beginning suggests some closing questions for this thread.
I cannot find "Quest oculus non vide, cor non delet" in the online versions of the code. Does anyone know where is it? An early version?
The phrase sounds like a quote, although it is called a proverb in some places, and there is a paraphrase in Lady Chatterley's Lover (the context is available online):
Does anybody know where "Quest oculus non vide, cor non delet" is from, if it is a quote?
Dana Densmore is a possibility. She received her BA from St. John's College in Annapolis, which has a "great books" curriculum and also teaches translating from the original.
Does anyone have any other suggestions?
Wow, @JudyMalloy, I've been hunting for this in the code and haven't found it. I assume you've seen this:
Attributed here to Clark Neily. But as to where it was in the code, or whether these subtitles appeared in the code or merely on the code, I can't tell.
Also, I've been looking at the other versions of the Apollo software and see earlier versions of that Executive.agc prioritization code. To determine, Hamilton's influence, we'd have to do more comparisons of at least Apollo 8 and Apollo 11, since I believe you mostly wrote that error handling section of Apollo 8, you know, the unimportant section that turned out to be so crucial.
@markcmarino says:
No I hadn't. Thanks!
And this seems like a good time to credit Ron Burkey for the extraordinary work he did in simulating the AGC and assembling documentation for the AGC
Following your link through Burkey's site, this document appeared:
Neily worked for MSC, which doesn't make him a likely candidate for inserting "Quest oculus non vide, cor non delet" into the software, but we don't know for sure.
Contingently, while we've been looking at the code, I've been thinking that the 1201 and 1202 alarms obscured the drama and complexity of the subsequent rendezvous of the Lunar Module with the Command Module, including more discussion of the rendezvous code.
Here's a figure from Grega and Neily (1969)
Working on this thread for #critcode has been a remarkable experience. Admittedly tackling the AGC source code was an unusual task, but with the manageable goals of exploring the commented code from a humanities point of view, affirming Margaret Hamilton's role, and identifying other women among the 350 coders who worked on the project, thanks to all of the voices here, it has been a productive and fascinating experience.
I come from the same era as Margaret Hamilton. I didn't look too different in the last years of the 1960's. Here I am in circa 1968:
So, I'd like to note that in July 1969 when the AGC accompanied the astronauts on Apollo 11, I was working for Ball Aerospace, where I was creating a technical information database in FORTRAN for an IBM system. Looking at this from an software engineering POV, I soon realized that more than code was involved in creating this system, and thus, when the moonwalk took place, I was at the University of Denver Graduate School taking a summer institute in systems analysis, and while I plunged into a course that would eventually completely alter the path of my life, I missed the excitement of watching the moonwalk with my colleagues at Ball.
Thus, for me, regaining this loss by exploring the AGC code has been cathartic. I don't regret the different path that I took into information art, electronic literature, and community networking in the arts, but I'd like to credit Ball Aerospace for what I learned from the responsibility I was given, and also to thank @markcmarino @jeremydouglass @lizlosh and @JacqueWernimont for supporting this CCSWG18 opportunity!
Hi All,
By way of introduction, I run the "Virtual AGC" project, which is the original online source for the LUMINARY and COLOSSUS source code you've been discussing. That project is devoted to collecting and making available every version of the AGC source code we can find (not just Apollo 11), as well as providing software for compiling that source code to executable code, providing a simulation engine allowing that AGC code to be run on modern computers, and various related activities.
At any rate, @markcmarino was kind enough to send me a note with links to 3 discussion threads of yours related to the AGC and Margaret Hamilton, and when I tossed together a few remarks to him after perusing those threads, he suggested that I should repost the reply I had sent to him here. I apologize for it thus being just random remarks rather than being specifically tied to any of your prior comments, as well as for likely being rather unrelated to the aims of your group and your discussion.
I have met Margaret Hamilton (nice lady!), and have in the past directed some questions similar to some of yours to her, though she has seldom given me a satisfactory answer to any of them.
But at least that leaves a lot of fertile ground for speculation.
My full response to Mark appears below my signature.
-- Ron
Thanks, Mark, I'm glad the website proved useful. This is not the kind of usage of the material that I ever imagined, but of course that's one of the advantages of an open-source approach, in that it can be used for things one never imagined initially.
I've read the links you gave --- though I admit that by the third thread I was thinking more about my lunch than anything else, and so was merely skimming . I can't say I have any great insights on the topics that were being discussed, though since the discussions appear to be over now, it doesn't matter too much that I have nothing to add. I do know who a couple of other women AGC programmers were, which was a question asked a couple of times in the threads. The best way to get a list seems to be reading the distribution lists suffixed to the ends of various Instrumentation Lab documents, since some of them break down specifically to groups, listing the names of the group leaders and group members. And there are Instrumentation Lab org charts which give a little of that info as well. My impression was that most but not all of the female programmers were working directly for Margaret (at the particular juncture for which I had information, anyway). Though I could be wrong. I'm sure that Phyllis Rye (who is credited in the code itself) is definitely in that category, for instance. At any rate, there's more information about the list of programmers I was able to verify on my website, and while the list is substantial, it's nowhere close to the 350 figure mentioned several times in your threads. Which isn't to say that that number is wrong per se, but I suspect that many of those 350 people were not directly involved in coding the software. Sadly, very little of the source code is internally credited, so we simply don't know who wrote it, or when. At one point I personally asked Margaret to help me dig out info from her personal stash of documentation to help me make such attributions, but she was unable to do so.
I think the thing that struck me primarily in your threads is the emphasis on receiving "credit" for Margaret and other female programmers, which is natural if there's a feminist emphasis on Margaret Hamilton's role specifically, but which I think is a weakness in understanding the AGC software-development effort as a whole.
The reason this occurred to me is a somewhat egocentric one, having to do with Chris Garry. The discussion threads repeatedly state that the discussion is based on AGC code that Chris Garry uploaded to github, quoting Chris Garry's comments, and so forth. The truth is that what Chris Garry really did was to just take the AGC source code from the Virtual AGC website, prune away everything not explicitly from Apollo 11, and then post the pruned version on github ... at which point social media (which had been ignoring Virtual AGC for over a decade) got wind of this "new" code and started making a big deal about Chris and the "sudden" availability of the Apollo 11 source code. Well, the availability wasn't sudden at all, and it illustrates how a body of work can be done by a group of people, and then suddenly one person becomes the poster child who draws all of the attention, even though the poster child himself never intended that to happen and may not have had quite as major a role one would like to assume.
What makes this relevant to your discussion about Margaret is the same thing is something like what seems to have happened with the original design of the AGC software itself, in a very mild way. The AGC software was created by a core group of 50 or so programmers, of whom exactly 2 (Margaret Hamilton and Don Eyles) have become the poster children who are the visible face of the development effort. I don't say that Hamilton & Eyles weren't extremely important --- they were very important! --- nor am I implying that they somehow unjustly wrested the attention for themselves. But it's unclear that they should be receiving all of the attention, or even most of it. Fortunately, most of the other AGC developers I've encountered are pretty self-effacing and don't seem to have a great problem with being personally invisible, and so they don't mind the focus being elsewhere. In fact a few seem to pathologically crave insignificance. But there are also probably a few who are wondering why they never got a Presidential Medal of Freedom.
Focusing on just Hamilton & Eyles is useful from a public perspective, of course, since the public doesn't care about 50 or 100 AGC programmers, and can barely work up enough interest for just the 2 they may have heard of. For example, just after Margaret got her Medal, I saw uninformed comments online from people who believed that she had won this for writing entire Apollo code by herself. Single-handedly. Ultimately, many historical names we revere are probably just catchphrases for groups of people rather than individuals. But it does tend to invite you to inflate the role of the poster children, and to search for their personal influences in places where there may have been none.
In understanding Margaret's coding role specifically, I also think that the discussion wasn't helped much by concentrating entirely on the Apollo 11 code. That emphasis on Apollo 11 probably also derives partially from depending on Chris Garry's github repository, because Chris was explicitly and unapologetically uninterested in any of the other Apollo missions. But neither the AGC code nor Margaret's involvement in it began or ended with Apollo 11. Both the code and Margaret's role evolved. Thus while it's true that Margaret was the "Colossus Programming Leader" for Apollo 11, it's not true that that's what she was prior to 11 or after 11, nor is it true that the code she wrote was even for Apollo 11 ... it was written long before, and had simply survived through many versions of the mission code. By the time of Apollo 15, she was "Director of Mission Program Development".
As far as code is concerned, she is internally credited (within the source code) only for the following:
That's not to say that Margaret didn't write other portions of the source code as well, though it would be unusual if she chose to credit herself for some sections of the code but not for others. It's more likely that she wrote code that was later replaced by other, improved code, written by other people. But which code? As I say, though, there are many, many sections of the code which are entirely without attribution, so if she chose not to credit herself, there are plenty of places where she may have been involved without our knowing about it. The "PINBALL GAME BUTTONS AND LIGHTS" code does talk about "Margaret's display subroutines", even though there's no obvious unambiguous trace of such subroutines still present by the time of Apollo 11 (or even 8). Not to mention the fact that there are many versions of the AGC code, particularly the early ones, that we simply don't have; who knows what was in them?
I think that's the real point I'm trying to get across: Since the AGC continually evolved over time, it's possible that Margaret wrote very important code which was eventually completely replaced; since she herself was promoted from being a coder to being a manager, this could leave her with practically no explicit code footprint in missions like Apollo 11. Which makes it very tough to determine the importance of her role by looking at any one version of the program, and particularly by looking at just the Apollo 11 code. The same thing can be said of quite a few other AGC developers as well.
As it happens I know that Margaret actually has at least one AGC version in her personal stash that we don't have, though I've had no luck in extracting it (or them) from her in the nearly 15 years I've been trying to get them. Well, who knows? Perhaps one day. (And perhaps my inability to extract them from her has something to do with my cautionary comments about her role. If she suddenly decides to send new AGC versions to me, say tomorrow, I'll personally award her a Ron's Medal of Freedom.
)
Hi @rburkey
Thanks for taking the time to visit CCSWG18!
As you note:
Yes, and thank you again for your information-dense site.
You write:
The focus on women is for this thread of Gender in Programming Cultures and is not intended to detract from the roles of the many other programmers who contributed to the Apollo 11 code.
You write:
I've been looking at Phyllis Rye in the past few days, but other than a few memos on your site, a family-oriented obit (which I didn't feel comfortable quoting) and a testimonial (which I think is from her) on the Hamilton Technologies site, I haven't found enough information. Do you know anything about Rye Associates, the company she lists in this kudo?
Alas, I do not. In fact, I wasn't aware that she was deceased, though that does explain why my contact info is out of date. Speaking of contact info, I wonder if you've thought of contacting Margaret directly with questions. She responds to the email address listed at the Hamilton Techologies site, though not necessarily in a timely fashion.
I don't know if it's of interest, but this morning I happened to have come across an email exchange I had in 2005 with a lady named Eileen Hughes, "a former AGC programmer", who originally gave me not only Phyllis's name, but also that of Naomi Fisher (who seems to have worked on the LUMINARY program). She mentions the following tidbits:
You may also have noticed references to Saydean Zeldin on the Hamilton Technologies website.
It has also occurred to me that it might be potentially interesting to have viewpoints from the AGC programmers themselves about the contributions of the female programmers. I don't quite recall what has been published online along those lines already, but I had in mind being able to ask your questions directly rather than relying on already-published material. Admittedly, it seems unlikely that you'd get too much useful insight from it. But who knows? If you like, I can inquire if any of them would like me to pass along their contact info to you.
Wow, this is incredibly useful, thanks, Ron!
You ask:
That would indeed be the next step. This is a 3-week discussion, so my intention was to identify whether or not the AGC code (here with a focus on the Apollo11 code) was of interest to humanities/gender scholars/researchers. There is now evidence that it is, and your identification of additional women is very helpful. The letter from Eileen Hughes is great, and I did find Saydean Zeldin's name but did not know she was a woman!
But where this goes from here (if anywhere) I don't yet know. It is an issue to discuss with @markcmarino @jeremydouglass and other hosts of CCSWG18.
You also suggest:
That also would be a good approach! In general CCSWG18 has worked with information in an online seminar context. My own approach in media archeology projects is to create edited books that solicit chapters from the people who actually did the work, as well as from people like you who have documented the work, but CCSWG projects have evolved differently. So these are all things to consider and discuss. MIT and the Smithsonian hold core documents. That is also an issue. And it would be great if Margaret Hamilton herself wanted to step in.
Thank you again for your help and offer of help and your generosity in taking the time to visit CCSWG! We'll keep you posted if this goes any further.
I didn't know about Saydean either, and stereotypically assumed she was a he.
There's a huge cc list that the AGC developers use to email news among themselves, as well as to a few others who have managed to horn in on it, such as myself. What I'd suggest is that I post a message to them asking that any who are interested in contributing to the discussion contact you (@JudyMalloy) directly, and you can work out whatever details you like with them. Margaret happens to be on that list, though I've never seen any messages from her on it, so I don't know if she reads it or not.
Does that seem reasonable?
Thanks, @rburkey Since CCSWG18 closes very soon, I'd prefer to wait until CCSWG talks about where (if anywhere) this discussion continues, and I don't think this is going to happen in the next few days.
Meanwhile, for those who are following here now, there is much of interest on Ron Burkey's site!
A picture of Margaret Hamilton and physicist Saydean Zeldin can be found in a NASA Flyer about Higher Order Software (HOS), the company these two women founded!
"Hamilton, far left, sits with some of her staff in the Scama room at MIT, while supporting the Apollo 8 mission. Photo: Margaret Hamilton."
The date of this photo is probably December 21, 1968, 50 years ago during the Apollo 8 launch. The SCAMA (Switching, Conference, And Monitoring Arrangement) room was where the MIT the Instrumentation Lab monitored the conversations between the astronauts and Mission Control and participated when necessary.
The photo appeared in Whale Oil
https://www.whaleoil.co.nz/2016/06/photo-day-761-49/
(where the caption is from)
and in
Rocket (wo)Man
https://issuu.com/sarahriedlinger/docs/final_gd1_p2
I addition to the software leader, Margaret Hamilton, other women who worked with MH at the MIT Instrumentation Lab on the AGC software and whom we've identified here in this thread are:
Dana Densmore
Naomi Fisher
Eileen Hughes
Phyllis Rye
Saydean Zelin
And to add to this list Madeline M. Sullivan
Madeline M. Sullivan
"Hybrid simulation of the Apollo guidance and navigation system
presented at the 1965 Fall Joint Computer Conference Las Vegas, Nevada"
Available at:
http://journals.sagepub.com/doi/pdf/10.1177/003754976600700114
I wanted to add another name to the list, Jayne Partridge Hanley, a staff engineer at the MIT Instrumentation Lab working on the Apollo projects. I'm not sure how involved she was with the code as much as the hardware, in particular circuits and semi-conductors. I'm enjoying the collaborative digging of this thread!
I found Jayne Partridge's name in the Draper (formerly the MIT Instrumentation Lab) report on the Apollo project. For those who haven't seen it yet, it's a great resource. In addition, due to the number of subcontractors working on the project, there's the possibility of looking through subcontractor files, with Raytheon, for instance.
Here's a round-up of info on Jayne Partridge Hanley (Sorry about all the Google Books links, but I've only been able to do some quick internet-sleuthing):
"Expanding the computer's role The MIT team— Eldon C. Hall, deputy associate director of the lab; L. David Hanley, assistant director; and Mrs. Jayne Partridge, a staff engineer — gave the system such a favorable report that the National Aeronautics and Space Administration expanded the role of the computer for Apollo." (Source: Electronics, Google Books)
"In 1963, Ms. Partridge Joined MIT Instrumentation Lab (now MIT Draper Lab) where she was responsible for the development, evaluation, selection, and reliability of the semiconductor parts used in the Apollo Guidance Computer." (Source: Annual Proceedings, Reliability Physics, Google Books)
"Jayne Partridge who compiled the data on the Apollo Computer" (Source: Application of Microelectronics to Aerospace Equipment, Google Books)
Jayne Partridge was quite the poet.
Great addition @Kir !
Thanks for your work on this.
None of the sources I've seen have highlighted this many women who worked on the AGC software, so this thread has resulted in some significant work.
And yes, the subcontractors are also of interest.
Well, a Raytheon subcontract employee named Henry Noble who worked under Margaret Hamilton for a while gave me the names of several other female Raytheon employees who were also there at the time. I was never able to really do much with this list myself, since Henry wasn't all too clear on the details and I couldn't verify or determine what they had been doing (in so far as the AGC software was concerned), but here's the list for whatever it is worth:
There are also quite a few other women on the AGC developers' mailing list, but as to whether they are AGC developers I don't know about, or NASA employees, or surrogates (wives, daughters) for AGC developers, or intruders on the list (like me), I don't know. Perhaps that's something that could be explored later if you want to get as complete a list as possible.
Thanks for the new names and for your suggestion, @rburkey
For the record, it should be noted that Margaret Hamilton's lead role in the group development of the AGC software has been confirmed both by NASA and by MIT
From the NASA History site:
Margaret Hamilton, Apollo Software Engineer, Awarded Presidential Medal of Freedom, Nov 22, 2016, NASA History
https://www.nasa.gov/feature/margaret-hamilton-apollo-software-engineer-awarded-presidential-medal-of-freedom
From MIT News,
"Apollo code developer Margaret Hamilton receives Presidential Medal of Freedom". MIT News, November 17, 2016
http://news.mit.edu/2016/apollo-code-developer-margaret-hamilton-receives-presidential-medal-of-freedom-1117