Code that powered space missions

Hey gang,

This came across my stream this morning and I thought there might be a few here who would get a kick out of it....

The Code that took Astronauts to the Moon is full of Comedy and Heroism

I've seen some pretty funny code/comments too, but I think some of these are just perfect.

It's not from a space mission, but an assembly language program had hundreds of lines with no comments, and then one instruction with the constant 1750 had the comment: RIPJSB

https://stackoverflow.blog/2021/12/23/best-practices-for-writing-code-comments/

Doesn't that imply that the compiler would have been on spacecraft computer? That makes no sense to me. Cross-compilers must have existed at the time to compile and assemble on the ground computers.

In my first serious software project in the mid 1970s we would have to have a project meeting when someone wanted to add a new field to the database. To fit it into memory it had to be controlled to the word in size and it was a case of finding something that could come out before anything else could go in. Disks were just not fast enough at time, although the db would be flushed to disk at every opportunity. Amazingly our 3D CAD programs are still in use nearly 50 years later, very successfully too 😀

Sorry, but I'm calling BS on your BS. I have no experience with Apollo Flight Computer code but I do have a masters in Software Engineering and I can assure you that no comments or variable names made it into memory on any computer of the time.

The code was written in assembly language and it was the assembler's job to turn reasonably readable mnemonics into actual machine language. Numbers are assigned locations in memory (today in the Data segment, back then in RAM for variables or ROM for constants). Operators are also turned into numbers to go in memory (today in the Text segment, back then in ROM). It was the assembler's job to keep track of where variables were stored so that all references pointed to the correct place, but these references were represented by numbers, usually operands for the operators in question.

None of the alphabetic content in the source listing survived the assembler; the output is nothing but a list of numbers, with some limited information for the loader, like "this block goes here".

An interesting note is that ROM in the AGC was organized as groups of address and data lines connected by ferrite cores (little transformers) where an address line either did or didn't have a core at an intersection with a data line. Since all the lines were parallel, it appeared as a rope with a sprinkling of cores. These were hand wired per instructions in a table; a very tedious and exacting job. Any constants had to be included in this coding so you can imagine the cost of a mistake or need for a correction.

BTW, the assembler noted above is a computer program that turns source into the file of numbers and loader instructions. In this case, the loader instructions became the recipe that the rope wirers followed. Much different than today where the loader is part of the operating system.