Hi, thanks for watching. I incorrectly said the landing was on 29 July, it was on the 20th. I just read it wrong on my script! Also this video is getting a few moon landing deniers unfortunately. I’ll try remove the more crazy comments but please ignore (unless you really want to get into an online argument!)
Although it's understandable enough to keep saying 1969... the truth is that the Inertial Guidance System (high-tech gyroscope) the Computer and its Software was the first contract issued for the Apollo mission, so its concepts and design are rooted in the key technologies of nearly a decade prior, and partly successful due to the foresight of what may be available when critical commitments to implementation are due - e.g. use of the first integrated circuits. The software was developed over a long time, and only just made the deadlines set for each critical step in the pathway.
hopefully, a decompiled version will be available! like c. historical we wrote in assembly, until we realize we can write higher level code like c to create assembly. then we wrote another layer like python and java to go a step further. java compiles to java bytecode, that then compile to an assembly with java virtual machine. there's no real reason to write in assembly, as most modern languages today compile to assembly. so we all still write in assembly. but with custom functions you can say.
Thank you for this video. Truly amazing software accomplishment. Amazing that NASA had this one-of-a-kind non-programmer computer-to-human interface. Also, you a beautiful and well spoken. Thank you again. Best Regards.
fwiw: Comanche is the European name for a very famous tribe of Native Americans inhabiting the Great Plains region of what is now the United States. Pronounced kuh-man-chee.
Yes, it was called magnetic core memory. It was really an amazing technology of the day bc it was non-volatile so it served double duty as RAM as well as flash.
@@TheWallReportsMagnetic core memory was a step up from using cathode ray tubes to write, store and read data. Thank heavens I never had to use cathode ray tubes for storage and I have a very time imagining what it was like to use mercury delay lines for memory.
I think you guys are getting two different technologies mixed up here. Magnetic-core memory was volatile and used for RAM, and while it was indeed hand-assembled it was done so in a manner that was the same for every cell. Core-rope memory, on the other hand, is the non-voltile/ROM technology that was hand woven by the so-call "little old ladies" at MIT. The former used the cores to store one bit in the ferrite material itself. The latter used the cores to read which wires passed through and which went around (with up to 64 wires per core in the case of Apollo). Two slightly similar, yet completely different, technologies.
There is a 1-to-1 correspondence between the assembly language and machine code. The programming logic is the same for both. Assembly provides human-friendly symbols that the assembler translates 1-to-1 into machine code instructions. Assemblers also provide human-friendly labels for memory addresses like jump/goto targets and data locations. Advanced assemblers also provide "macros" that substitute sequences of assembly instructions with a single command, similar to how macros in office software like word processors and spreadsheets work. Once macro code is substituted and memory address symbols are resolved, again, it's 1-to-1 translation to machine code. Early microcomputers like the Altair and minicomputers like the PDP-11 had front panels with displays a little similar to the AGC DSKY. You could enter the instructions in binary and read results in binary from display lights. The DSKY was more user-friendly (no binary) in this regard as it provided command symbols on the keypad and decimal values for the display and keypad.
One other thing to keep in mind about assembly language is that it's not a single language. Each processor architecture's assembly language is unique; e.g., the AGC's assembly looks completely different from 6502 assembly, which looks completely different from i386 assembly, which looks completely different from ARM assembly, which... you get the idea. This was because assembly instructions map 1:1 to machine instructions, which of course are completely different for different architectures.
@@markrosenthal9108it's not necessarily 1:1. Assemblers support macros that can turn one assembly statement into 2 or more machine code instructions. MIPS CPUs don't have an instruction for loading a 32 bit constant, but there is a "pseudo instruction" li, which is turned into lui + or. The main difference is you can use all the instructions available, while high level languages only use a subset and they won't let you directly use things like CPU flags. An issue that I have faced is C not letting you detect carry or math overflows without wasting time on unnecessary calculations
@@markrosenthal9108 It's not quite 1:1, because even without a macro assembler, there are tricks you can do with machine code, that's difficult or meaningless with assembler, like designing code that executes differently if you jump into the middle of a multi-byte instruction in an instruction set that supports a variable-length instruction set (like x86 or Z80 or 6502 or 68K).
I started playing with computers around '69/70 and started programming for space systems around '80. When I began, cards were for development and paper tape was for finished code (it was more compact but really really annoying to edit). Fast forward ten years to around 1980 and terminals faster than a TTY were starting to become common, which made all the programmers happier -- even at 300 baud. That said, I was still doing a fair amount of programming with cards well into the 80s. Many programs were developed using FORTRAN to work out the algorithms and logic (C wasn't yet mainstream, nor vetted for space missions where I worked) and chase out a lot of the bugs, but in the end we were still translating that by hand into "optimized" and commented assembly (i.e. just compiling and doing an assembly dump as a shortcut wasn't an option). It was a treat when you got to use an AL you already knew from a previous computer; still, you ended up learning a lot of them.
I have worked on Assembly language programs and it really finds out your weaknesses and forces you to learn. I am not a professional developer BTW, but I do have a passion for embedded systems. I know why they used assembly so much back in the day. It was their only real option. Thank goodness for really good compilers and large memories nowadays. WE ARE SPOILED.
👍🏾True. The thing with Assembly Language and same can be said for machine language is the coder has to know & understand the actual CPU & hardware bc you're working & manipulating registers & memory directly more less depending on whether virtual memory mode is active.
I still remember my first days meeting with assembly. It was in 3rd elementary... No, I was not some Sheldon Cooper level genius in some "gifted kids' school". It was early 90s, and my school decided to buy modern computers (so 286s instead of Comodore64) and start computer science courses for the kids. It was really forward thinking at the time, sure, but there was one tiny problem. None of the teachers knew ANYTHING about computers, so they assigned the science teacher to learn about computers from books and teach kids what she learned. Basically she was ahead of the classes she taught by one or two lessons. And what exactly you think they thought would be the best way to introduce kids into computer science? Yes, exactly what you thought: Assembly language. During the first few lessons we learned what peripherials are, then right after that we were introduced to registers, stacks and heaps and data manipulation verbs. In like two months, all the kids were taken out of that course by the parents.
@@Jenny_Digital Same here. I wrote a few simple arcade games in 6502 back in the 80's on my Atari 800. 6502 was so simple that it made it very difficult to program. At college in 1987 I took an assembly language class which involved programming a mainframe computer. I don't remember the name of the CPU but the assembly was much more advanced making it fairly easy.
@@jp5000able I had an Acorn Electron with only a black and white telly and a tape recorder, but the built-in assembler meant I got my start in 1983 when I was only six. I had no printer so I typed my listings using an imperial widecarriage typewriter my dad had rescued from the tip whilst working for the council. Back then my computer came with a very comprehensive user guide, getting started book and demo tape. Now you get a sheet or two of paper telling you how to plug the thing in and not to open it.
Curious Marc is a treasure trove channel. Going to auctions, nabbing old gear, doing hardware debugging, rebuilding display tech... Then casually piloting a landing. They are amazing.
Actor Jack Black's mum worked on the Abort-Guidance System (AGS) in the Apollo Lunar Module. In what has to be one of the best quotes ever... "In a memorial tribute, her son Neil notes that she was troubleshooting problems with schematics on the day she went into labor, called her boss to let him know she had fixed the problem and then delivered Jack". The calculations and measurements were also done in metric and displayed in imperial units as was simpler.
@@Alkatross you do! All imperial measures in the USA are based on metric standards. The US inch has always been 25.4mm. However in the UK its varied over time - even at one point 1 inch being 27mm. also US military - 1 click = 1km.
I went to the Smithsonian a couple of decades ago now and was absolutely stunned by the technology and computers used to go to the moon. It looked absolutely archaic in design. I literally saw soldering points on the greenboards for wires. I was told at the time they had triple redundancies because of the anticipated shaking that might loosen the wires. My respect for those astronauts only grew tenfold when I saw that capsule and those components. Now, I have heard that we have to relearn how to go to the moon, because most of those brilliant engineers are now dead and things were kept on paper. Wow. You would have thought that we would have kept and or recorded these kinds of things, even if for only posterities sake. Great video, thanks for taking the time to explain it.
I remember machine code and hand compiling 6502 programs into hex! I also remember watching the landing live, aged 12. BTW it was July 20th 1969 not the 29th. As a computer operator back in 1983ish punch cards were still in regular use where I worked. Having recently retired after 40+ years in IT, based on talking to recent graduates I get the impression that basically Assembler is no longer taught in college. This is a mistake; short of some kind of electrical engineering degree there is, in my opinion, no better way to understand what the hardware's doing.
Great Video Thanks! Don Eyles on of the programmers responsible for those jokes wrote an interesting book called “Sunburst and Luminary an Apollo Memoir” about his time working on Apollo.
The 1201 and 1202 Alarms were causing AGC reboots during the Apollo 11 Landing. This extended the range of the de orbit and landing engine burn. The low level assembly language allowed the AGC to keep up with required tasks, even with frequent reboots. Reboots were near instantaneous. I always wanted to find out how long it took Mission Control to isolate the problem to the enabled Rendezvous Radar. Note: Apollo 14 Landing used a lot of fuel also. They had only a minute of fuel remaining at Touchdown. Apollo 14 had an issue with a landing abort switch with an intermittent short that had to be isolated with an in orbit re-write of the Luminary Code. Loved watching your video! 👏👏👏
I have always injected some humour into the code and continue to do so - mostly for my own amusement - sometimes as a monument/reminder of some insight that would otherwise get lost in time. I enjoy seeing it in other people's code too, it does have some utility beyond putting a smile on a tired developer's face though... What I have found is that third parties looking at the code latch onto those bits and pieces, they give an otherwise featureless jumble of code some landmarks - which folks can use to navigate the code (and share in the insights of the original developer).
As long as you make comments. Especially in assembler. Joe Armstrong (the inventor of Erlang) made a joke about the commenting behaviour of one of his colleagues: It was one big file of assembly code and in the middle of the file there was just one sentence: " ;And now for the tricky bit!" 😆
As long as what needs to be known can be known, putting in a little humor or a note to future programmers is like putting a note in a bottle and casting it into the sea. Who knows who will eventually read that note, and how this little bit of humanity will affect their appreciation of the code. I think the comments also help document a point in history with slang or literary or movie references. If done tastefully and with a sense of balance, these comments give us insight not only in the code, but of the programmer.
There is a book about the Apollo guidance computer called "The Apollo Guidance Computer Architecture and Operation" which is pretty good reading. It had a preemptive and cooperative multiprogramming, an interpreter to implement more complex instructions.
Correct me if I'm wrong but my understanding of the AGC is that it was NOT calculator some are led to believe. To believe would be absurd. But what was meant by that statement is it had the computation power inline of that of a calculator but far more capable bc of it's preemptive & cooperative multi-tasking abilities.
@@TheWallReports I guess the problem is also that different people think of different things when thinking of a calculator. When I think of a calculator I think of a non-programmable device which has keys for a fixed set of mathematical operations and a display capable of showing a single number; however there were other electronics also going under the name of calculator that could be programmed and had graphical displays, and which IMHO would qualify as pocket computers.
@@TheWallReports It looks like a calculator because it use a VERB/NOUN interface but it could do a lot of things. The verb was a two digit code that defined the action for 00-99. The lower codes were for early stages on mission like prelaunch while later codes were used for later parts of the mission like navigation, descent and landing back on earth. This interface was something the developers came up with while expected something better in the future but nobody could think on anything better. The CPU had 16 bit registers. With the interpreter they implemented opcodes on double width registers doing trig functions and vector/matrix operations needs for flight control. The CPU had access via IO to many sensors and engine controls. The AGC were quite capable but the ground facilities had much more powerful computers to augment the AGC because there were weight constraints on how big a on board AGC could be.
"Comanche" is pronounced as /ko-man'-chee/. "ko" rhymes with "go" but can be softened to "kuh". The second syllable is emphasized; "man" is exactly like "man". And "chee" rhymes with "me". The Comanche tribe of Native Americans here in the USA are headquartered in the state of Oklahoma.
@@msromike123, the typical American pronunciation is /uh-loo'-muh-num/. Emphasis on the second syllable. The last two syllables can be /min-um/ instead. You can blame our first prolific dictionary editor for all that. Old Noah Webster.
I was in the US Air Force, and we used punch cards well into the 80s. It was in the 90s, if I recall correctly, that we switched over to a system of remote terminals. Even then, it was the old system at heart, but you could enter data directly rather than via punch cards. This allowed for real-time updates to maintenance data rather than overnight batch processing.
Yep... I still remember the thrill of the first IBM 3270 terminal in the shop with CICS to enter our code on. The senior programmers hogged it up most of the time...
When I was in the Marine Corps, I was almost a mainframe operator. Still even lists that MOS on my dd214 as a secondary MOS. Luckily, due to some priority changes, I went to school to be a Small Computer Systems Specialist (an IT guy basically), but then ended up actually doing UNIX sysadmin work. I was around a lot of mainframe folks, though, both Marines and civilians.
Note: Assembly code is platform specific. X86 assembly is very different than ARM64 or 6502 assembler. They have completely different syntax, opcodes, registers, etc. Each CPU type's assembly code is essentially it's own language and there is generally no direct parallel between different platforms.
Oldish assembly coder here. Whilst assembly can be different on each platform, the biggest difference is big endian and little endian. Where basically the code is written backward. (Kinda). And yes, opcodes, registers, memory etc. all different but that can even be different from the same architecture to the next in the same architecture.
I agree they are different but.... I know Microchip assembly vey well, and if I have a quick look at a reference manual, I can easily read and understand any other flavor of Assembly.
@@TheHeff76endian is rather insignificant, big endian is easier for a programmer to read but slower for the computer (little endian let's you start doing maths as soon as it's read the lowest significant byte) Load/store Vs register/memory architecture is a more important distinction. The way the 6502 updates flags after every instruction while 8080/z80 only does it on a few, is a larger difference. Even the indexing modes on 6502 are vastly superior. Trying to switch between 6502 and z80 (which are both little endian) can be annoying, the 6502 is the best CPU ever.
@@phill6859 I've never done anything with the 6502, but I heard it had very few registers. Also, every instruction updating the flags sounds more like a nightmare to me; what if you want to test more than one flag? Also it means that you'll more often need to store the flag's value somewhere else for later reference.
@@__christopher__depending on which instruction is running only some of the flag bits are changed not all of them. Normally only the logic like and, or, not, rotate OR math like add, sub, compare effected any of the flags then use conditional jumps to branch on status. Even though it might refresh the flags on every instruction it doesn't usually change any of them.
Ah, the good old days when programming was creative and fun, when code wasn't shipped until it was just about perfect. Also, the verb/noun paradigm is so well-suited to human command logic. Great video. Enlightening. Entertaining. Well done,
I mean, the noun-verb paradigm was the true genius of the system. It was such an elegant solution to the size and weight limitations necessary in the AGC human interface component. Also, an amazing design in light of the need for the astronauts to be able to accurately interpret the output from, and make input to the AGC in times of extreme stress. Mind boggling!
You'd better be sure that most of the work on the Apollo software was not fun but very tedious. Those jokes tell a story of exasperation. On the flip side, coding can be very much fun today, and modern software can be far more reliable than what even those most brilliant programmers of the 60s were able to do with their limited tooling. If your experience tells you otherwise then perhaps you should look a bit more around for better projects, other programming languages, etc..
Ah, the good old days when requirements were so simple and constrained. Even the smallest app today does so many more things than just "Fly rocket to moon". And then a separate program "Land it".
Assembly is still very much relevant today. In fact, every single time you compile software, you are compiling it into ASM (Assembly) and then the assembler takes over from there.
Great summary of the AGC. As others have posted Curious Marc and team have brought back an AGC and rebuilt the code for multiple missions. Current video they are debugging ground radio commands to remotely program the AGC. Given the state of the art back then it was a fantastic accomplishment. Less well know is the LVDC (Launch Vehicle Digital Computer) that guided the Saturn 5 and astronauts to orbit designed by IBM.
Has LVDC been published like the Apollo 11 source? I'd love to see that code. Maybe Curious Marc could restore that hardware for an encore to the AGC project
Apollo's AGC was the first computer to use ICs (Integrated circuit / Chips) There was a lot of discussion about this but the team decided that they were the only way the project could be realized
Whilst they used some super basic logic gate ICs in the AGC, the real leap goes to the CADC in the Grumman F14 Tomcat which was designed in ~1968-70 and used the first set of ICs that would in combination be considered a microprocessor, the computer being the only way to make the swing wing design flyable
Great video! This relates to my favorite computer hack on Apollo 14 to bypass the abort button. It’s too much to type in a comment but might be something for you to cover in a future video
I got to stay up late to watch the lunar landing as a 9 year old in 1969. My family lived then in Biloxi, Mississippi, so we experienced both Hurricane Camille AND the first manned mission to the moon in one exciting month. Oh, and the TV was black and white, a 19" Magnavox if I recall correctly. Assembly language is what caused me to change my major circa 1980 from computer science to economics.
We were using punch cards up through 1991 on our ship. We had to learn Hollerith code and even had 5-channel paper tape and magnetic tape. We had guys coming down from various departments, sometimes with several BOXES full of the cards. Every once in a while, they would trip on the ladder (stairwell) coming down to our shop to give us the job! Those cards were stacked sequentially and had NO writing on them. They had to go back to their shop and re-run the entire job again to get the output. :)
So they missed the trick of running a pen down the side of a stack of cards at a slight angle so that even if the cards get shuffled it's quick and easy to get them back into order.
@@Heater-v1.0.0 Our cards were punched and also had the text printed at the top of the card. We were taught to tab over to the comment part of the punch card starting at I believe column 72 and type a sequential number. No one ever did it, since it was so slow to move over there. Dropping your punched card deck was everyone's nightmare.
@@dermick Yeah, we didn't bother numbering our cards when punching in Algol code in 1976. Seems a lot of people didn't cotton on to the trick of running a marker pen down the side of the deck. Anyway, luckily by 1977 we had terminals to a timesharing OS , no more card punching. Then very soon came micro-processors and personal computers. Happy days...
I learned 6502 assembly language progamming on the Apple ][ computer, a decade after the 1969 Apollo 11 moon launch. The page layout and formatting of the Apollo Guidance Computer assembly code is strikingly familiar, and similar to the assembly language syntax and commenting standards I used and encountered in programming Apple ][, Commodore 64, and IBM PC computers in the 1980's and beyond. It's inspirational to see how low-level programming culture and techniques evolved from the earliest examples of embedded systems programming on machines that predated modern microprocessors.
My first programming was less than a decade after the moon-landing and we had a landline from college (UK, so age 16 to 18) to a local university mini-computer. The link terminal had a huge telex-keyboard and a paper-roll instead of a cathode-raye tube screen, and then you had to wait for most of the lesson (or frequently until the next one) to get the inevitable error message about a typo in line ten, or maybe the results of the program if you had been extra careful. A DSKY like the Apollo had was massively ahead of it's time. NASA has large public archives concerning the tasks and planning for the tens or hundreds of thousands of people involved in the project, and the solutions to the new problems that had never previously needed solving.
Catching up was indeed a problem, with no budgets for that sort of thing as computer use was percieved to be just something for accountants . . . The more enthusiastic students had Commodore or TRS80 machines at home, at about the same time as the telex-and-paper terminals in college!
But but but Stanley Kubrick and the studio! And what about the Van Allen Belt? Huh, what about that pretty lady? And everyone now knows that only computers can do complex math! Got'cha there...
I remember playing with discarded punch cards as a child back in the early 1980s, I guess. My parents were students at the time & one of their student jobs was loading punch cards into the university's computers (and taking them out again later). They brought home a bunch, mostly to be used as note pad replacements. They also caused my child brain to imagine all kinds of funky things for all those strange hole patterns. Thank you very much for this fascinating & entertaining dive into our past; definitely one of humanity's most uplifting & most impressive achievements ever.
i can see why there are moon conspiracies. these engineers performed MAGIC. forget the primitive hardware, the sheer elegance of practical code to control a system of that complexity seems like scifi mumbo jumbo.
@@airaction6423 Science hasn’t been prioritized since then. Even back then, it took the Cold War to make governments and their citizens see science as a high priority.
@@airaction6423The reasoing is in the wall The US went there for geopolitical reasons. Win the cold war. It went there after apolo 11 too. Multiple times. Then the space race was won...and the cold war itself was won. The US government virtually defunded NASA. It had served its purpouse Thats why. And its sad.
Really interesting thanks for your video! I read too that HP-41 calculators were used as backup devices by astronauts on Apollo missions back then. I still have my HP-41CV and managed to power it up 40 years later.
I'm 67, at school they stopped the whole school for the Lunar landing wheeled out a television and we watched the landing LIVE. Later on in my Career I spent 40+ years in IT. A specialist in Aerospace/Defence, several languages, no machine code, megabytes of code. Yes I put in jokes. They can be useful. If an error says "Tony your shorts are on fire" in correction you go straight to the place in the code. "Error 404" could be anywhere. NOW THE IMPORTANT PART. For Apollo they taught me that they programmed in triplicate. For a key calculation three programmers would code the algorithm. The calculation on the onboard computer would run all three in parralel. If all three did not agree the result, it would display the two majority result. If All three were different it was "Shorts on Fire". From my experience they could not run the whole of the system in triplicate (we can now) this would be sub sections of code.
I started learning programming when I was 19 in 83. 8086/8088 assembly code was the common language. I still use 8086 assembly as BASIC is often to limited. I got to watch a Saturn 5 launch in 71. That is when I got the programming bug. Thanks for this information.
It's a great computer, incredible for the time. Good fun to program, I made a couple of games for it a few years ago and in terms of raw speed is on par with 8-bit computers from the 80s. I had to put in artificial delays so the games wouldn't run too fast.
I love the image of the Tektronix 7854 oscilloscope. Much like the AGC, it was a magnificently capable waveform processing instrument that combined analog, sampling, and the introduction to digital processing capabilities. Those were exciting times for technology.
I once wrote a machine code routine to handle graphics on a 6809 8 bit computer and the result was instant execution, insead of a painfully slow MS 1.0 Basic interpreter solution. So source code is very important. :) Was a PID/process simulator.
Great video! I always think of the AGC as an HP-12C on steroids-you input numbers, store them in registers, and call commands to have the "calculator" compute and give you results. The part where it gives the astronaut instructions to correct the trajectory works like that. The astronaut observes the positions of 40+ stars and inputs them into the computer, entering the star number and its position. Then, the AGC calculates the required correction, providing the result in terms of thrust duration and timing. This meant the astronauts had to manually ignite the thruster and control how long it stayed on (which is where the beautiful Omega Speedmaster came into play). The AGC didn’t control the thrusters directly or track positions automatically. I’d love to see what the AGC code would look like in C or another modern programming language.
I felt like I was on this mission just based on your description of the code...Excellent!!! 🚀
15 часов назад
I started hearing the comparison of AGC to a calculator when graphic calculators, at the end of the 90's, started being more powerful (in terms of computational power) than AGC was. I've never thought it'd be linked to the interface.
As an ex assembly programmer (on PDP 11 about a decade after this) I can add that it was good practice to comment every line of code. They were after all cryptic instructions involving registers and memory locations. Actually the PDP 11 had a great assembler. All registers could be incremented and used as memory pointers. Once you added Macros you were close to C. Actually C was essentially sugared PDP assembly code.
As a fellow PDP-11 programmer I approve this 😁. Just a small addition to the nice comments: I once saw this comment (IMHO also citing Shakespeare): 'Our faults dear Brutus are not in our stars, but in ourselves' - error handling function of the RT-11 operating system. I used RT-11 sometimes, but mainly worked with RSX-11M. All were 'real programmers', not just quiche eaters 🤣.
Likewise... this brings back equal memories of nightmares (when it didn't work) and huge euphoria (when it finally did work). We were interfacing A/D's to PDP-11 for data acquisition. Set up "Ping Pong" buffers so the A/D could be writing to Ping while the PDP-11 could read Pong; write to disk... then flip the pointers. Hopefully the "bathtub" never overflowed while filling and draining at the same time. It was those other pesky interrupts from disk writes that could ruin things... now, what was the sustained disk write speed for 8k vs 16k vs 32k block-writes???? As I get close to retirement age (actually past it, but still love being an engineer), I'm thinking about getting into Arduino's for Halloween projects.
@@EngRMP The Arduino is good. I'd recommend getting some of the clones, particularly the nano version. I would also recommend using 2.54mm pin header socks and connectors so the parts can be removed and replaced easily. while I generally gravitate towards the ESP32 , ESP8266, and the raspberry pi pico. However those devices use 3.3 volt logic vs the Arduino's 5 volt logic. It's easier connecting sensors and output devices to the Arduino since most are going to be 5 volt logic and you won't require additional hardware. Get yourself a package about a hundred 2n222 transistors or some 2n7000 fets. It's possible to drive higher power mosfets directly, but if I remember correctly 70 ma is about the most you want to source from the Atmel 328 and stay within safety parameters. There's no real advantage to using real Arduino boards over the clones. I hope you'll enjoy building projects with Arduino as much as I have. The only limitations are going to be your imagination and your wallet. Oh...I usually buy in quantities of 10 so if something goes wrong I have plenty of spares available without any waiting. Besides this stuff is cheap. Take care.
I never actually wrote any useful PDP-11 assembly code, but my 2nd-semester programming course in college (Spring 1972) involved writing a PDP-11 simulator in the first half of the course and then a PDP-11 assembler in the second half, so I became fairly familiar with the PDP-11 instruction set. They made some nice design choices. The auto-increment and auto-decrement addressing modes were useful in lots of situations, and having the program counter be one of the 8 registers meant that pc-relative addressing for branches and subroutine calls was available to the programmer (or compiler writer) without it having to be a special distinct addressing mode.
The book “Sunburst and Luminary: An Apollo Memoir” by Don Eyles is also an amazing look at the creation of the AGC and specifically the software from the start.
I went to college in the late 80s. I was the first CompSci class to NOT use punch cards for computer programming classes. My internship was at a company that still used a punch card machine; for FIVE cards per day! So, this technology lingered on and on!
Same. I learned on PDP-11s running RSTS/E in college on the 80s. We’d use VT52 terminals or even the teletype machines in the lab. But on my work experience I had to deal with punched cards and paper tape.
@@TesterAnimal1 Yes, well, this is typical for every Generation. In Universities we mostly learn the cutting edge science and tooling (but also sometimes got optical EEPROMS for programming an SPS 🙂). When you come to industry then you realize, that most of them are at least 10 years behind.
I took a programming course (FORTRAN) at a college in the summer before my senior year of High School. We used punch cards. By the time I started at the same college as a freshman, in 1978, punch cards were obsolete.
Great video, thanks for doing this. I'm a big fan of the AGC. It really was an amazing accomplishment and in many ways it drove the advances in cpu design, computer architectures, and software development that set the stage for the computer revolution that followed. If you are interested in this kind of computer history, there is a book titled Apollo Guidance Computer that goes through its hardware and software in lots of detail, yet remains approachable even if you don't write machine code just for the fun of it. That being said, your video provided come insights that weren't in the book. By the way, I think most calculator comparisons are based on memory or processing power and are rarely accurate.
Great video! Loved it, used to enjoy programming my first computer (C64) in machine code. Very impressed with the source code that made sure we REALLY could land on the moon and get back safely!
I loved the video and appreciate the background information provided. I should point out that Margaret Hamilton was certainly not standing next to a single listing of the source code. Someone computed the entire github repo to contain 1,751 pages which would not create a stack that size. The most likely explanation is that it is a culmination of test data run against the source or possibly several printouts stack for effect.
I was not programming in days of Apollo, but started in 80' and still do. I also like to have small touches in naming or comments, but I have noticed modern generations of programmers are some times much stiffer, and do not take it well always. It seems a lot of playfulness has disappeared over the time, I miss it.
Very well researched and well presented. Thank you. Didn’t know the part about the original software engineer. History has a way of missing and looking past such milestones and just focusing on the three guys playing footie out in space.
Excellent video. For anyone interested in learning more, I recommend the excellent memoir “Sunburst and Luminary” by one of the software engineers, Don Eyles. Also, the BBC podcast “13 minutes to the moon” does an amazing job of putting you right into the drama of those 13 minutes from undocking from the command module to landing on the lunar surface.
thanks this is great. I remember watching the broadcasts from the moon like it was yesterday. Grabbed the github repo reading through the source code will be fun. I've done assembly language programming for three different processors but that was decades ago. I will probably have to learn this now so I can understand what the code is doing. Thanks again this will be a lot of fun.
Thank you, Dee, it was a huge pleasure and fun to listen. A great information, easy to understand and making appetite for more (subscribed your channel). kindly, a software developer who used different assembly languages in early ;)
I started my computer course at Control Data Corp's Institute in 1969. I was so disappointed that they were no longer teaching how to jumper wire boards! Before the end of the course, we stopped using paper tape. Soon after that (in my career), we stopped using punch cards. Today, AI is taking over. Wow. What will replace it? Today's students will work with technology that may not exist for a decade. Learn to think!
Thank you for bringing this to light--wonderful! Just amazed by the immensity of the challenge to put a person on the moon. And the bravery of those who were involved.
An excellent description of the detail in the moon landing software! However, as a veteran software engineer from way back, I spotted some minor errors you might want to fix. For example, at 12:28, the description, "comments are in grey and are followed by a hashtag" is backwards. Comments in most programming languages are PRECEEDED by a hashtag (or other reserved symbol). The hashtag is how the program parsing routines tell that this data is a comment, since it reads the code sequentially left to right. Next, at about 7:00, you mention a "smartphont". That must be a new version of a smartphone. :)
Thank you for the video. I mostly just assumed it was still analog in those days. Anyways some more interesting things. The thing has a 2mhz clock that took 4 cycles to execute. So code ran 500khz. Which was probably ground breaking at the time. Yes assembly. But very different than say x86 or arm. There was only 11 instructions. 4 primary registers. And it was 16bit without floating point.... What I don't get is why they would print it out other than for a cool photo. Anyways. Margaret def another unsung hero I will tell my little girls about
Also a very important thing to remember when comparing the AGC with a “normal” computer, a “normal” computer is designed to handle a lot of things, whereas the AGC was designed for one thing and one thing only, taking the CSM and LM to their respective destinations and nowhere else. It wasn’t that they too a computer off the shelf and made the programs to fit, they started from scratch with what was needed to perform the task at hand and then designing the AGC from that standpoint
Seeing how it is still difficult today to put a craft on the moon (there have been recent failures), let alone a human, it makes NASA’s success in putting 12 people on the moon with 1960s technology even more awe inspiring. When done right, a government agency can do fantastic things. Private enterprise can too, but only if there is a profit motive. Public good vs private profits.
Did you know there is a 2nd DSKY on the Command Module? It is down near the sextant system. The entire PDI was mainly several programs, run in order to run a quarter ellipse path to the surface. Neil partially took over to manuver to the other side of a crater they were over. Also, if memory serves me correctly, the code 1201 & 1202 only showed up because rendezvous was on (and it shoundn't have been). If just the landing radar would have been on, things would have been fine.
I used to write customer tech documentation to go with patch releases. We (myself & a colleague) concocted the idea to include an innocuous recipe white characters on a white background on a blank page. Sadly we bottled it, in a way I wish we hadn't.
Yes, so source code I have seen has had comments that aren't quite safe for work. The guy writing it was very angry about how some of the hardware worked.
”CC” in the mission transcript was not an abbreviation of ”control center” - it means ”capcom” (capsule communicator) which was an astronout working in Mission Control (Houston) tasked with talking to the astronauts. So anything Mission Control decided, capcom was the one telling the astronauts on radio.
People might be amazed to know that there is STILL a LOT of IBM BAL assembly code running - especially in large, critical applications where companies deem it just too expensive to rewrite, test, and certify the new code. The banking industry is notorious for this - lots of ancient code on HOGAN systems and still running heirarchical databases like IMS...
Checking online, it cuts deeper - that "burn baby burn" line was first used during the race riots in 1965 by a Radio DJ named Magnificent Montague in America... Super video, one of my absolute favourite software topics is the AGC. Many thanks for taking your time here, yet getting it all done in under 20 minutes. Well impressed! I am interested in what kind of instruction set they had available to them in terms of a Von Neumann machine, to be writing assembly on a portable computer in the late 60s. And also that the tech had to be shielded from extreme physical forces - ploughing thru Earth's atmosphere. And also, as others have said here in the comments, the actual point-to-point wire-weaving of the memory modules for the AGC, by real seamstresses with actual needles and a ball of wire, is the other most-phenomenal of facts about this software-hardware machine! Thanks for the upload, subbed 👍
This channel is AWESOME i can't believe it took yt so long to reccomend this to me. Looking forward to more content from you Dee! Now if you'll excuse me im gonna binge watch this channel
Wishes can be your best avenue of getting what you want when you turn wishes into action. Action moves your wish to the forefront from thought to reality.
The thing a lot of folks don't realize if they hadn't written code in that era is that you optimized your own code. It wasn't just a matter of getting the program to correctly run. (That, of course, was vital because you can't fix the software on the LEM on location :) ) It was also a matter of squeezing as much code into as little space as possible because memory was so limited. You're doing this balancing act with efficient coding on one side and readable code on the other (because people other than you needed to be able to read it and quickly understand what you were doing.) That said, I don't regret that we have optimizing compilers and high-level languages today. The other thing that I remember from writing code in (approximately) this era was that there were lots of jokes and "easter eggs" buried in the comments usually (because you couldn't waste memory on a joke.) I can remember a much later computer system where an unused system error message was actually coded as "massive system conniption fit."
Conniption is a noun meaning a fit of rage so "conniption fit" is a fit of rage fit. (Also an assembly programmer, I once spent 2 years cramming the code to control a payphone into 2k of ROM.)
Assembly it’s not an “older” language. It’s still used today, specially on drivers and controllers. Albeit it’s a mnemonic language for the Machine Language, with a few additional features. Before assembly there were other languages (or computer programming languages/scripts).
I never gave up on writing wry and humorous comments. One I wrote in a unit test referenced a quote from Damian Guy: "Every time a mock returns a mock, a fairy dies." There was a particular case where a mock returning a mock was the most straightforward way to get the job done. My comment read: "// Sorry, fairies!" BTW, there isn't just one assembly language: it is very specific to the type of machine. Back in the day, I wrote PDP-8, RCA 1802, Motorola 6809, Quantel QIC, IBM 360, Intel 808x, and Intel 8048/51. There isn't much call for it anymore, except maybe for certain microcontroller applications. The main advantage is in hand-optimization, but modern compilers are better than hand-optimization, and modern CPUs have pipelines and out-of-order instruction scheduling, not to mention multiple cores and thread context switches. If one weren't insane before hand-optimizing for a modern CPU, it would happen pretty quickly.
PDP-8, A DEC machine called "Link", DP1802, Intel 8080 (z80), 8051, 386, Various PIC, and at least one I forget are on my list. There was more than one for the Z80 because I used a tiny one too.
I think the comparison of the AGC to a high end pocket calculator of a decade or more later is probably accurate in comparison of operations per second or some other hardware capability metric, but as you said a calculator runs a very simple program compared to the AGC and it was underpowered since those 1201 and 1204 alarms during Apollo 11's descent were literally saying the hardware could not handle all of the operations being asked of it.
Based on my experience using assembly language in the 1970s, you needed some sense of humor or else you would lose your mind. Most of the humor in my code and those of my colleagues was more like graveyard humor and rather dark. The comments and subroutine names you quoted are much more amusing than the ones we had.
If you have ever done any software development, but especially embedded software development, you have to write software within the constraints of the hardware you have available If your software throws an error because of a hardware failure, then you need to figure out how to write your software so that it doesn't produce that error. I'm sure the programmers are upset, I've been blamed for hardware errors, but the reality is that you need to deal with it.
Yeah I'm a systems engineer, and have developed software for embedded systems, even with some assembly routines and specialized hardware and the issue with the radar was a software bug, not only a hardware issue. Nowadays at universities when you take this course, they show you slides regarding accidents that have happened due to not handling these errors, where the outcome might have been fatal. It's definitely a priority and it has to be dealt with by the software.
Programmers in that timeframe had to really understand the hardware in order to accomplish complicated tasks with limited resources. The first real-time systems I developed were on PDP-11/23s with 128 KB of memory. When we later got 256 KB, we thought we had hit the lottery. Sadly, most programmers today haven’t a clue how their hardware works. This level of abstraction enabled by ultracapable hardware has both its good points and its bad points.
My first paid programming job in 1981 we did not have a card reader available so I had to hand enter some Fortan code from a printout. I would not have had that opportunity if this comments section was available back then! 😂
I remember hearing many years ago that it was common for software companies to print their source code on paper. Maybe a legal thing or some kind of backup. Just funny to see it.
I would have guessed that the Shakespeare comment referred to the fact that the interface consisted of entering a verb and a noun, as explained earlier in the video.
17:00 *_"CC"_* stands for *_"Capsule Communicator"_* - or; *_CAPCOM_* which was the only person who could talk directly to the Astronauts. *_ALL_* spoken communication went to the Astronauts though this one person - including the Flight Director! The reasoning being; You don't want 20 people's voices being sent to the Astronauts at the same time. "CC" is *_not_* "Control Center" - this was an incorrect "guess" of what the CC abbreviation stood for...
"Burn baby burn - Disco Inferno!". That's how I know that phrase. But that was a disco hit from the 70's - way after Apollo... Checking online, it cuts deeper - that "burn baby burn" line was first used during the race riots in 1965 by a Radio DJ in America named Magnificent Montague... Super video, one of my absolute favourite software topics is the AGC. Many thanks for taking your time here, yet getting it all done in under 20 minutes. Well impressed! I am interested in what kind of instruction set they had available to them, in terms of a modern computing device / von Neumann machine, for them to be writing assembly on a portable computer in the late 60s! And also that the tech had to be shielded from extreme physical forces - ploughing thru Earth's atmosphere. And also, as others have said here in the comments, the actual point-to-point wire-weaving of the memory modules for the AGC, by real seamstresses with actual needles and a ball of wire, is the other most-phenomenal of facts about this software-hardware machine! Thanks for the upload, subbed 👍
As someone born before the moon landings, it's tragic how we just stopped going for both my generation and for the vast majority of people now who were born way after the last Apollo moon mission (ignoring Skylab). The era had hope built-in, and if you were never there, there must be a massive undercurrent of a lack-of-hope. I do have a copy of the source code - Luminary 12? I always figured it was one of the best arguments against the moon landings being faked, because you don't need 36KW of working software and 2/3 of the global chip supply if nothing actually needed to get there.
FYI, "Burn Baby Burn" was a term associated with the 1965 Watts Riots. It was often quoted by college students of the time. The MIT programmers would have been familiar with it's source and meaning.
