Editing Apollo Guidance Computer (section)

==Design==
[[File:Agc nor2.jpg|right|thumb|300px|Photograph of the dual NOR gate chip used to build the Block II Apollo Guidance Computer. Connections (clockwise from top center) ground, inputs (3), output, power, output, inputs (3). ]]
[[File:Agc nor2a.jpg|thumb|AGC dual 3-input NOR gate schematic]]
[[File:Agc flatp.jpg|thumb|150px|right|[[Flatpack (electronics)|Flatpack]] [[silicon]] [[integrated circuit]]s welded to PCB in the Apollo guidance computer]]
The AGC was designed at the [[MIT Instrumentation Laboratory]] under [[Charles Stark Draper]], with hardware design led by [[Eldon C. Hall]].<ref name="Hall-1996">{{Citation | first = Eldon C. | last = Hall | author-link = Eldon C. Hall | title = Journey to the Moon: The History of the Apollo Guidance Computer | place = Reston, Virginia, USA | publisher = [[American Institute of Aeronautics and Astronautics|AIAA]] | year = 1996 | page = 196 | isbn = 1-56347-185-X }}</ref> Early [[computer architecture|architectural work]] came from [[J. Halcombe Laning|J. H. Laning Jr.]], [[Albert Hopkins (computer scientist)|Albert Hopkins]], [[Richard Battin]], Ramon Alonso,<ref name="mithist">{{citation |url=http://authors.library.caltech.edu/5456/1/hrst.mit.edu/hrs/apollo/public/conference1/alonso-intro.htm |title=Ramon Alonso's introduction |publisher=MIT |date=July 27, 2001 |work=AGC History Project (Caltech archive, original site closed) |access-date=2009-08-30}}</ref><ref name="ray_alonso_interview">{{citation |url=http://www.lanacion.com.ar/nota.asp?nota_id=1240769
|title=Ramon Alonso's interview (Spanish) |publisher=Diario La Nacion |date=March 7, 2010 |work= Ramón Alonso, el argentino que llevó a la Apollo 11 a la Luna}}</ref> and Hugh Blair-Smith.<ref>
{{citation |url=http://authors.library.caltech.edu/5456/1/hrst.mit.edu/hrs/apollo/public/people/hblairsmith.htm |title=Hugh Blair-Smith biography |publisher=MIT |date=January 2002 |work=AGC History Project (Caltech archive, original site closed) |access-date=2009-08-30}}</ref>
The flight hardware was fabricated by [[Raytheon]], whose Herb Thaler<ref>{{citation |url=http://authors.library.caltech.edu/5456/1/hrst.mit.edu/hrs/apollo/public/conference2/thaler-intro.htm |title=Herb Thaler introduction |publisher=MIT |date=14 September 2001 |work=AGC History Project (Caltech archive, original site closed) |access-date=2009-08-30}}</ref> was also on the architectural team.

According to Kurinec et al, the chips were welded onto the boards rather than soldered as might be expected.<ref>{{cite web|first1=Santosh K |last1=Kurinec | first2=Mark |last2 = Indovina|first3= Karl|last3=McNulty|first4= Matthew |last4=Seitz|title=Recreating History: Making the Chip that went on the Moon in 1969 on Apollo 11|date=2021|url=https://www.rit.edu/imagine/exhibit-extras/Apollo-Guidance-Computer-ImagineRIT-SKurinec.pdf|access-date=29 August 2023|website=Rochester Institute of Technology|page=9}}</ref> Apollo Guidance Computer logic module drawings specify resistance-welding.<ref name="NASA1003074">{{cite web |title=LOGIC MODULE ASSEMBLY NO. A1-A16 |url=https://archive.org/details/AgcApertureCardsBatch8Images/page/n4/mode/1up?view=theater |publisher=MIT Instrumentation Lab |page=Sheet 1 of 2, Note 2 |date=July 11, 1963}}</ref><ref name="ND1002005">{{cite web |title=Apollo Requirements for Process Control and Fabrication of Resistance-Welded Electronic Circuit Modules and Assemblies |url=https://archive.org/details/aperturecardbox432naraswimages/page/n815/mode/1up?view=theater |website=Archive.org |publisher=NASA |access-date=19 February 2024 |date=May 22, 1963}}</ref>
===Logic hardware===
Following the use of [[integrated circuit]] (IC) chips in the [[Interplanetary Monitoring Platform]] (IMP) in 1963, IC technology was later adopted for the AGC.<ref>{{cite book |last1=Butrica |first1=Andrew J. |chapter=Chapter 3: NASA's Role in the Manufacture of Integrated Circuits |editor-last1=Dick |editor-first1=Steven J. |title=Historical Studies in the Societal Impact of Spaceflight |date=2015 |publisher=[[NASA]] |isbn=978-1-62683-027-1 |pages=149–250 |url=https://www.nasa.gov/sites/default/files/atoms/files/historical-studies-societal-impact-spaceflight-ebook_tagged.pdf}}</ref> The Apollo flight computer was one of the first computers to use [[silicon]] IC chips.<ref name=":2" /><ref name=":1">{{cite web |title=Apollo Guidance Computer and the First Silicon Chips |url=https://airandspace.si.edu/stories/editorial/apollo-guidance-computer-and-first-silicon-chips |website=[[National Air and Space Museum]] |publisher=[[Smithsonian Institution]] |access-date=1 September 2019 |date=14 October 2015}}</ref>

While the Block I version used 4,100 ICs, each containing a single three-input [[NOR gate]], the later Block II version (used in the crewed flights) used about 2,800 ICs, mostly dual three-input NOR gates and smaller numbers of expanders and sense amplifiers.<ref name="HALL-MITRole"/>{{rp|27,266}} The ICs, from [[Fairchild Semiconductor]], were implemented using [[resistor–transistor logic]] (RTL) in a [[Flatpack (electronics)|flat-pack]]. They were connected via [[wire wrap]], and the wiring was then embedded in cast [[epoxy]] plastic.<ref name="HALL-MITRole" />{{rp|129}}

The use of a single type of IC (the dual NOR3) throughout the AGC avoided problems that plagued another early IC computer design, the [[LGM-30 Minuteman|Minuteman II]] [[D-37C|guidance computer]], which used a mix of [[diode–transistor logic]] and [[diode logic]] gates.{{citation needed|date=February 2018}} NOR gates are [[Logic gate#Universal logic gates|universal logic gates]] from which any other gate can be made, though at the cost of using more gates.<ref>Peirce, C. S. (manuscript winter of 1880–81), "A Boolian Algebra with One Constant", published 1933 in ''[[Charles Sanders Peirce bibliography#CP|Collected Papers]]'' v. 4, paragraphs 12–20. Reprinted 1989 in ''[[Charles Sanders Peirce bibliography#W|Writings of Charles S. Peirce]]'' v. 4, pp. 218–21, Google [https://archive.org/details/writingsofcharle0002peir/page/218]. See Roberts, Don D. (2009), ''The Existential Graphs of Charles S. Peirce'', p. 131.</ref>

===Memory===
The computer had 2,048 words of erasable [[magnetic-core memory]] and 36,864 words of [[read-only memory|read-only]] [[core rope memory]].<ref name="HALL-MITRole">{{cite book |last1=Hall |first1=Eldon C. |title=MIT's Role in Project Apollo: Final report on contracts NAS 9-163 and NAS 94065 |date=1972 |publisher=MIT |location=Cambridge, MA |url=http://ibiblio.org/apollo/hrst/archive/1029.pdf |access-date=15 June 2021}}</ref>{{rp|27,90–93}} Both had cycle times of 11.72&nbsp;microseconds.<ref name="HALL-MITRole" />{{rp|27}} The memory word length was 16 bits: 15 bits of data and one odd-[[parity bit]]. The [[central processing unit|CPU]]-internal [[16-bit]] word format was 14 bits of data, one [[arithmetic overflow|overflow]] bit, and one [[sign bit]] ([[ones' complement]] representation).<ref name="HALL-MITRole" />{{rp|35–37}}

==={{anchor|DSKY}} DSKY interface===
[[File:Apollo display and keyboard unit (DSKY) used on F-8 DFBW DVIDS683588.jpg|thumb|250px|Apollo computer DSKY user interface unit]]
[[File:Apollo DSKY interface.svg|thumb|250px|right|LM DSKY interface diagram]]
The [[user interface]] to the AGC was the ''DSKY'', standing for ''display and keyboard'' and usually pronounced ''"DIS-kee".'' It has an array of indicator lights, numeric displays, and a [[calculator]]-style keyboard. Commands were entered numerically, as two-digit numbers: [[Verb]] and [[Noun]]. ''Verb'' described the type of action to be performed and ''Noun'' specified which data were affected by the action specified by the Verb command.

Each digit was displayed via a green (specified as 530&nbsp;nm<ref>{{Cite web|url=https://www.youtube.com/watch?v=feRCZyLzAwA?t=1405|title = Apollo DSKY panel relight: The full story|website = [[YouTube]]| date=27 July 2021 }}</ref>) high-voltage [[electroluminescent display|electroluminescent]] [[seven-segment display]]; these were driven by electromechanical [[relay]]s, limiting the update rate. Three five-digit signed numbers could also be displayed in [[octal]] or [[decimal]], and were typically used to display [[vector (geometry)|vectors]] such as space craft [[Aircraft attitude|attitude]] or a required velocity change ([[delta-V]]). Although data was stored internally in [[International System of Units|metric units]], they were displayed as [[United States customary units]]. This calculator-style interface was the first of its kind.

The command module has two DSKYs connected to its AGC: one located on the main instrument panel and a second located in the lower equipment bay near a [[sextant]] used for aligning the [[inertial guidance]] platform. The lunar module had a single DSKY for its AGC. A [[flight director (aviation)|flight director attitude indicator]] (FDAI), controlled by the AGC, was located above the DSKY on the commander's console and on the LM.

===Timing===
The AGC timing reference came from a 2.048&nbsp;MHz [[crystal oscillator|crystal]] [[clock rate|clock]]. The clock was divided by two to produce a [[clock signal#4-phase clock|four-phase 1.024&nbsp;MHz clock]] which the AGC used to perform internal operations. The 1.024&nbsp;MHz clock was also divided by two to produce a 512&nbsp;kHz signal called the ''master frequency''; this signal was used to synchronize external Apollo spacecraft systems.

The master frequency was further divided through a ''[[clock divider|scaler]]'', first by five using a ring counter to produce a 102.4&nbsp;kHz signal. This was then divided by two through 17 successive stages called F1 (51.2&nbsp;kHz) through F17 (0.78125&nbsp;Hz). The F10 stage (100&nbsp;Hz) was fed back into the AGC to increment the [[real-time clock]] and other involuntary counters using Pinc (discussed below). The F17 stage was used to intermittently run the AGC when it was operating in the ''standby'' mode.

===Central registers===
The AGC had four 16-bit [[processor register|register]]s for general computational use, called the ''central registers'':
* '''A''': The [[accumulator (computing)|accumulator]], for general computation
* '''Z''': The [[program counter]] – the address of the next instruction to be executed
* '''Q''': The remainder from the <code>DV</code> instruction, and the [[return address (computing)|return address]] after <code>TC</code> instructions
* '''LP''': The lower product after <code>MP</code> instructions

There were also four locations in core memory, at addresses 20–23, dubbed ''editing locations'' because whatever was stored there would emerge shifted or rotated by one bit position, except for one that shifted right seven bit positions, to extract one of the seven-bit interpretive op. codes that were packed two to a word. This was common to Block I and Block II AGCs.

===Other registers===
[[File:ApolloGuidanceComputerwithDSKY.dwt.jpg|thumb|DSKY and AGC prototypes on display at the [[Computer History Museum]]. The AGC is opened up, showing its logic modules.]]
[[File:AGClogicmodule.agr.jpg|thumb|Prototype logic module from Block I AGC]]
[[File:Agc mount.jpg|thumb|Block II logic module, with flat-pack ICs]]
The AGC had additional registers that were used internally in the course of operation:
* '''S''': 12-bit memory address register, the lower portion of the memory address
* '''Bank/Fbank''': 4-bit ROM bank register, to select the 1&nbsp;[[kiloword]] ROM bank when addressing in the fixed-switchable mode
*'''Ebank''': 3-bit RAM bank register, to select the 256-word RAM bank when addressing in the erasable-switchable mode
* '''Sbank''' (super-bank): 1-bit extension to Fbank, required because the last 4&nbsp;kilowords of the 36-kiloword ROM was not reachable using Fbank alone
*'''SQ''': 4-bit sequence register; the current instruction
*'''G''': 16-bit memory buffer register, to hold data words moving to and from memory
*'''X''': The 'x' input to the ''adder'' (the adder was used to perform all [[ones' complement|1's complement]] arithmetic) or the increment to the program counter ('''Z''' register)
* '''Y''': The other ('y') input to the adder
*'''U''': Not really a register, but the output of the adder (the [[ones' complement]] sum of the contents of registers '''X''' and '''Y''')
*'''B''': General-purpose buffer register, also used to pre-fetch the next instruction. At the start of the next instruction, the upper bits of '''B''' (containing the next op. code) were copied to '''SQ''', and the lower bits (the address) were copied to '''S'''.
*'''C''': Not a separate register, but the ones' complement of the '''B''' register
* '''IN''': Four 16-bit input registers
* '''OUT''': Five 16-bit output registers

===Instruction set===

The [[instruction set|instruction format]] used 3 bits for [[opcode]], and 12 bits for address. Block I had 11 instructions: <code>TC</code>, <code>CCS</code>, <code>INDEX</code>, <code>XCH</code>, <code>CS</code>, <code>TS</code>, <code>AD</code>, and <code>MASK</code> (basic), and <code>SU</code>, <code>MP</code>, and <code>DV</code> (extra). The first eight, called ''basic instructions'', were directly accessed by the 3-bit op. code. The final three were denoted as ''extracode instructions'' because they were accessed by performing a special type of <code>TC</code> instruction (called <code>EXTEND</code>) immediately before the instruction.

The Block I AGC instructions consisted of the following:
;<code>TC</code> (transfer control): An unconditional branch to the address specified by the instruction. The return address was automatically stored in the Q register, so the <code>TC</code> instruction could be used for subroutine calls.
;<code>CCS</code> (count, compare, and skip): A complex conditional branch instruction. The A register was loaded with data retrieved from the address specified by the instruction. (Because the AGC uses [[ones' complement]] notation, there are two representations of zero. When all bits are set to zero, this is called ''plus zero''. If all bits are set to one, this is called ''minus zero''.) The ''diminished absolute value'' (DABS) of the data was then computed and stored in the A register. If the number was greater than zero, the DABS decrements the value by 1; if the number was negative, it is complemented before the decrement is applied—this is the absolute value. ''Diminished'' means "decremented but not below zero". Therefore, when the AGC performs the DABS function, positive numbers will head toward plus zero, and so will negative numbers but first revealing their negativity via the four-way skip below. The final step in <code>CCS</code> is a four-way skip, depending upon the data in register A before the DABS. If register A was greater than 0, <code>CCS</code> skips to the first instruction immediately after <code>CCS</code>. If register A contained plus zero, <code>CCS</code> skips to the second instruction after <code>CCS</code>. Less than zero causes a skip to the third instruction after <code>CCS</code>, and minus zero skips to the fourth instruction after <code>CCS</code>. The primary purpose of the count was to allow an ordinary loop, controlled by a positive counter, to end in a <code>CCS</code> and a <code>TC</code> to the beginning of the loop, equivalent to an [[System/360|IBM 360]]'s <code>BCT</code>. The absolute value function was deemed important enough to be built into this instruction; when used for only this purpose, the sequence after the <code>CCS</code> was <code>TC</code> *+2, <code>TC</code> *+2, <code>AD</code> ONE. A curious side effect was the creation and use of ''<code>CCS</code>-holes'' when the value being tested was known to be never positive, which occurred more often than one might suppose. That left two whole words unoccupied, and a special committee was responsible for assigning data constants to these holes.
;<code>INDEX</code>: Add the data retrieved at the address specified by the instruction to the next instruction. <code>INDEX</code> can be used to add or subtract an index value to the [[base address]] specified by the operand of the instruction that follows <code>INDEX</code>. This method is used to implement arrays and table look-ups; since the addition was done on both whole words, it was also used to modify the op. code in a following (extracode) instruction, and on rare occasions both functions at once.
;<code>RESUME</code>: A special instance of <code>INDEX</code> (<code>INDEX</code> 25). This is the instruction used to return from interrupts. It causes execution to resume at the interrupted location.
;<code>XCH</code> (exchange): Exchange the contents of memory with the contents of the A register. If the specified memory address is in fixed (read-only) memory, the memory contents are not affected, and this instruction simply loads register A. If it is in erasable memory, overflow "correction" is achieved by storing the leftmost of the 16 bits in A as the sign bit in memory, but there is no exceptional behavior like that of <code>TS</code>.
;<code>CS</code> (clear and subtract): Load register A with the ones' complement of the data referenced by the specified memory address.
;<code>TS</code> (transfer to storage): Store register A at the specified memory address. <code>TS</code> also detects, and corrects for, [[arithmetic overflow|overflow]]s in such a way as to propagate a carry for multi-precision add/subtract. If the result has no overflow (leftmost 2 bits of A the same), nothing special happens; if there is overflow (those 2 bits differ), the leftmost one goes the memory as the sign bit, register A is changed to +1 or −1 accordingly, and control skips to the second instruction following the <code>TS</code>. Whenever overflow is a possible but abnormal event, the <code>TS</code> was followed by a <code>TC</code> to the no-overflow logic; when it is a normal possibility (as in multi-precision add/subtract), the <code>TS</code> is followed by <code>CAF</code> ZERO (<code>CAF</code> = <code>XCH</code> to fixed memory) to complete the formation of the carry (+1, 0, or −1) into the next higher-precision word. Angles were kept in [[single precision]], distances and velocities in [[double precision]], and elapsed time in triple precision.
;<code>AD</code> (add): Add the contents of memory to register A and store the result in A. The 2 leftmost bits of A may be different (overflow state) before and/or after the <code>AD</code>. The fact that overflow is a state rather than an event forgives limited extents of overflow when adding more than two numbers, as long as none of the intermediate totals exceed twice the capacity of a word.
;<code>MASK</code>: Perform a bit-wise (boolean) ''and'' of memory with register A and store the result in register A.
;<code>MP</code> (multiply): Multiply the contents of register A by the data at the referenced memory address and store the high-order product in register A and the low-order product in register LP. The parts of the product agree in sign.
;<code>DV</code> (divide): Divide the contents of register A by the data at the referenced memory address. Store the quotient in register A and the absolute value of the remainder in register Q. Unlike modern machines, [[fixed-point arithmetic|fixed-point numbers]] were treated as fractions (notional decimal point just to right of the sign bit), so you could produce garbage if the divisor was not larger than the dividend; there was no protection against that situation. In the Block II AGC, a double-precision dividend started in A and L (the Block II LP), and the correctly signed remainder was delivered in L. That considerably simplified the subroutine for double precision division.
;<code>SU</code> (subtract): Subtract (ones' complement) the data at the referenced memory address from the contents of register A and store the result in A.

Instructions were implemented in groups of 12 steps, called ''timing pulses''. The timing pulses were named TP1 through TP12. Each set of 12 timing pulses was called an instruction ''subsequence''. Simple instructions, such as TC, executed in a single subsequence of 12 pulses. More complex instructions required several subsequences. The multiply instruction (<code>MP</code>) used 8 subsequences: an initial one called <code>MP0</code>, followed by an <code>MP1</code> subsequence which was repeated 6 times, and then terminated by an <code>MP3</code> subsequence. This was reduced to 3 subsequences in Block II.

Each timing pulse in a subsequence could trigger up to 5 ''control pulses''. The control pulses were the signals which did the actual work of the instruction, such as reading the contents of a register onto the bus, or writing data from the bus into a register.

===Memory===
[[File:Agc rope.jpg|thumb|250px|AGC [[core rope memory]] (ROM)]]

Block I AGC memory was organized into 1 kiloword banks. The lowest bank (bank 0) was erasable memory (RAM). All banks above bank 0 were fixed memory (ROM). Each AGC instruction had a 12-bit address field. The lower bits (1-10) addressed the memory inside each bank. Bits 11 and 12 selected the bank: 00 selected the erasable memory bank; 01 selected the lowest bank (bank 1) of fixed memory; 10 selected the next one (bank 2); and 11 selected the ''Bank'' register that could be used to select any bank above 2. Banks 1 and 2 were called ''fixed-fixed'' memory, because they were always available, regardless of the contents of the Bank register. Banks 3 and above were called ''fixed-switchable'' because the selected bank was determined by the bank register.

The Block I AGC initially had 12 kilowords of fixed memory, but this was later increased to 24 kilowords. Block II had 36 kilowords of fixed memory and 2 kilowords of erasable memory.

The AGC transferred data to and from memory through the G register in a process called the ''memory cycle''. The memory cycle took 12 timing pulses (11.72&nbsp;μs). The cycle began at timing pulse 1 (TP1) when the AGC loaded the memory address to be fetched into the S register. The memory hardware retrieved the data word from memory at the address specified by the S register. Words from erasable memory were deposited into the G register by timing pulse 6 (TP6); words from fixed memory were available by timing pulse 7. The retrieved memory word was then available in the G register for AGC access during timing pulses 7 through 10. After timing pulse 10, the data in the G register was written back to memory.

The AGC memory cycle occurred continuously during AGC operation. Instructions needing memory data had to access it during timing pulses 7–10. If the AGC changed the memory word in the G register, the changed word was written back to memory after timing pulse 10. In this way, data words cycled continuously from memory to the G register and then back again to memory.

The lower 15 bits of each memory word held AGC instructions or data, with each word being protected by a 16th odd parity bit. This bit was set to 1 or 0 by a parity generator circuit so a count of the 1s in each memory word would always produce an odd number. A parity checking circuit tested the parity bit during each memory cycle; if the bit didn't match the expected value, the memory word was assumed to be corrupted and a ''parity alarm'' panel light was illuminated.

===Interrupts and involuntary counters===
The AGC had five vectored [[interrupt]]s:
* ''Dsrupt'' was triggered at regular intervals to update the user display (DSKY).
* ''Erupt'' was generated by various hardware failures or alarms.
* ''Keyrupt'' signaled a key press from the user's keyboard.
* ''T3Rrupt'' was generated at regular intervals from a hardware timer to update the AGC's [[real-time clock]].
* ''Uprupt'' was generated each time a 16-bit word of uplink data was loaded into the AGC.
The AGC responded to each interrupt by temporarily suspending the current program, executing a short interrupt service routine, and then resuming the interrupted program.

The AGC also had 20 involuntary [[Counter (digital)|counters]]. These were memory locations which functioned as up/down counters, or shift registers. The counters would increment, decrement, or shift in response to internal inputs. The increment (''Pinc''), decrement (''Minc''), or shift (''Shinc'') was handled by one subsequence of microinstructions inserted between any two regular instructions.

Interrupts could be triggered when the counters overflowed. The T3rupt and Dsrupt interrupts were produced when their counters, driven by a 100&nbsp;Hz hardware clock, overflowed after executing many Pinc subsequences. The Uprupt interrupt was triggered after its counter, executing the Shinc subsequence, had shifted 16&nbsp;bits of uplink data into the AGC.

===Standby mode===
The AGC had a power-saving mode controlled by a ''standby allowed'' switch. This mode turned off the AGC power, except for the 2.048&nbsp;MHz clock and the scaler. The F17 signal from the scaler turned the AGC power and the AGC back on at 1.28 second intervals. In this mode, the AGC performed essential functions, checked the standby allowed switch, and, if still enabled, turned off the power and went back to sleep until the next F17 signal.

In the standby mode, the AGC slept most of the time; therefore it was not awake to perform the Pinc instruction needed to update the AGC's real time clock at 10&nbsp;ms intervals. To compensate, one of the functions performed by the AGC each time it awoke in the standby mode was to update the real time clock by 1.28 seconds.

The standby mode was designed to reduce power by 5 to 10&nbsp;W (from 70&nbsp;W) during midcourse flight when the AGC was not needed. However, in practice, the AGC was left on during all phases of the mission and this feature was never used.

===Data buses===
The AGC had a 16-bit read bus and a 16-bit write bus. Data from central registers (A, Q, Z, or LP), or other internal registers could be gated onto the read bus with a control signal. The read bus connected to the write bus through a non-inverting buffer, so any data appearing on the read bus also appeared on the write bus. Other control signals could copy write bus data back into the registers.

Data transfers worked like this: To move the address of the next instruction from the B register to the S register, an RB (read B) control signal was issued; this caused the address to move from register B to the read bus, and then to the write bus. A WS (write S) control signal moved the address from the write bus into the S register.

Several registers could be read onto the read bus simultaneously. When this occurred, data from each register was inclusive-''OR''ed onto the bus. This inclusive-''OR'' feature was used to implement the Mask instruction, which was a logical ''AND'' operation. Because the AGC had no native ability to do a logical ''AND'', but could do a logical ''OR'' through the bus and could complement (invert) data through the C register, [[De Morgan's laws|De Morgan's theorem]] was used to implement the equivalent of a logical ''AND''. This was accomplished by inverting both operands, performing a logical ''OR'' through the bus, and then inverting the result.

=== Software ===

[[file:Margaret Hamilton - restoration.jpg|thumb|upright|[[Margaret Hamilton (software engineer)|Margaret Hamilton]] standing next to listings of the software she and her MIT team produced for the [[Apollo program|Apollo Project]].<ref name="Weinstock2016">{{Cite web
 | title       = Scene at MIT: Margaret Hamilton's Apollo code
 | last        = Weinstock
 | first       = Maia
 | work        = MIT News
 | date        = 2016-08-17
 | access-date = 2016-08-17
 | url         = https://news.mit.edu/2016/scene-at-mit-margaret-hamilton-apollo-code-0817
}}</ref>]]

AGC software was written in AGC [[assembly language]] and stored on [[rope memory]]. The bulk of the software was on read-only rope memory and thus could not be changed in operation,{{Sfn|Mindell|2008|pp=154, 157}} but some key parts of the software were stored in standard read-write [[magnetic-core memory]] and could be overwritten by the astronauts using the DSKY interface, as was done on [[Apollo 14]].

A simple [[real-time operating system]] designed by [[J. Halcombe Laning]]<ref name="Hoag">{{cite web|url=http://klabs.org/history/history_docs/mit_docs/1711.pdf|last=Hoag|first=David|title=The History of Apollo On-board Guidance, Navigation, and Control|date=September 1976|publisher=Charles Stark Draper Laboratory}}</ref> consisting of the 'Exec', a batch job-scheduling using [[cooperative multitasking|cooperative multi-tasking]],{{Sfn|Mindell|2008|p=149}} and an [[interrupt]]-driven [[Fixed-priority pre-emptive scheduling|pre-emptive scheduler]] called the 'Waitlist' which scheduled timer-driven 'tasks', controlled the computer. Tasks were short threads of execution which could reschedule themselves for re-execution on the Waitlist, or could kick off a longer operation by starting a 'job' with the Exec. Calculations were carried out using the [[metric system]], but display readouts were in units of feet, feet per second, and nautical miles – units that the Apollo astronauts were accustomed to.<ref name="metric">{{cite web|url=https://ukma.org.uk/why-metric/myths/metric-internationally/the-moon-landings/
|last=|first=|title=The Moon landings|date=18 October 2018|publisher=UK Metric Association}}</ref>

The AGC  had a sophisticated software interpreter, developed by the [[MIT Instrumentation Laboratory]], that implemented a [[virtual machine]] with more complex and capable pseudo-instructions than the native AGC. These instructions simplified the navigational programs. Interpreted code, which featured double precision [[trigonometry|trigonometric]], scalar and vector arithmetic (16 and 24-bit), even an <code>MXV</code> (matrix × vector) instruction, could be mixed with native AGC code. While the execution time of the pseudo-instructions was increased (due to the need to interpret these instructions at runtime) the interpreter provided many more instructions than AGC natively supported and the memory requirements were much lower than in the case of adding these instructions to the AGC native language which would require additional memory built into the computer (in [[history of computing hardware (1960s–present)#Third generation|the 1960s]] memory was very expensive). The average pseudo-instruction required about 24 ms to execute. The assembler, named ''YUL'' for an early prototype ''Christmas Computer'',<ref>{{citation |url=http://authors.library.caltech.edu/5456/1/hrst.mit.edu/hrs/apollo/public/conference3/blairsmith.htm |title=Hugh Blair-Smith's Introduction |publisher=MIT
|date=30 November 2001 |work=AGC History Project (Caltech archive, original site closed) |access-date=2010-03-21}}</ref> enforced proper transitions between native and interpreted code.

A set of interrupt-driven user interface routines called 'Pinball' provided keyboard and display services for the jobs and tasks running on the AGC. A set of user-accessible routines were provided to let the astronauts display the contents of various memory locations in [[octal]] or decimal in groups of 1, 2, or 3 registers at a time. 'Monitor' routines were provided so the operator could initiate a task to periodically redisplay the contents of certain memory locations. Jobs could be initiated.

The design principles developed for the AGC by [[MIT Instrumentation Laboratory]], directed in late 1960s by [[Charles Stark Draper|Charles Draper]], became foundational to [[software engineering]]—particularly for the design of more reliable systems that relied on [[Asynchrony (computer programming)|asynchronous software]], [[Scheduling (computing)#Priority scheduling|priority scheduling]], testing, and [[human-in-the-loop]] decision capability.<ref name=apolo11>{{cite press release |url=https://www.nasa.gov/history/alsj/a11/a11Hamilton.html |title=NASA Honors Apollo Engineer |date=September 3, 2003}}</ref> When the design requirements for the AGC were defined, necessary software and programming techniques did not exist so they had to be designed from scratch. Many of the trajectory and guidance algorithms used were based on earlier work by [[Richard Battin]].<ref name="Hoag"/> The first command module flight was controlled by a software package called CORONA whose development was led by Alex Kosmala. Software for lunar missions consisted of COLOSSUS for the command module, whose development was led by Frederic Martin, and LUMINARY<ref>{{cite web | url=https://www.ibiblio.org/apollo/Luminary.html | title=Virtual AGC Luminary Page }}</ref> on the lunar module led by George Cherry. Details of these programs were implemented by a team under the direction of [[Margaret Hamilton (scientist)|Margaret Hamilton]].<ref name=":0">{{Cite magazine|url=https://www.wired.com/2015/10/margaret-hamilton-nasa-apollo/|title=Her Code Got Humans on the Moon—And Invented Software Itself|last=Harvey IV|first=Harry Gould|date=13 October 2015|magazine=WIRED|access-date=2018-11-25|language=en-US}}</ref> Hamilton was very interested in how the astronauts would interact with the software and predicted the types of errors that could occur due to human error.{{Sfn|Mindell|2008|p=149}}<ref name=":0" /> In total, software development on the project comprised 1400 [[person-years]] of effort, with a peak workforce of 350 people.<ref name="Hoag"/> In 2016, Hamilton received the [[List of Presidential Medal of Freedom recipients#Computing|Presidential Medal of Freedom]] for her role in creating the flight software.

The Apollo Guidance Computer software influenced the design of [[Skylab]], [[Space Shuttle]] and early fly-by-wire fighter aircraft systems.<ref name=klabs>{{cite web |publisher=NASA Office of Logic Design |url=http://klabs.org/home_page/hamilton.htm |title=About Margaret Hamilton |date=February 3, 2010}}</ref><ref name=50th>{{cite web |author=A.J.S. Rayl |url=http://www.nasa.gov/50th/50th_magazine/scientists.html |title=NASA Engineers and Scientists-Transforming Dreams Into Reality |archive-url=https://web.archive.org/web/20160516060422/http://www.nasa.gov/50th/50th_magazine/scientists.html |archive-date=May 16, 2016 |url-status=dead}}</ref> 

The Apollo Guidance computer has been called "The fourth astronaut" for its role in helping the three astronauts who relied on it: [[Neil Armstrong]], [[Buzz Aldrin]] and [[Michael Collins (astronaut)|Michael Collins]].<ref>{{cite web|url=https://www.bbc.co.uk/programmes/w3csz4dn|website=bbc.co.uk|publisher=[[BBC World Service]]|first=Kevin|last=Fong|year=2019|title=13 minutes to the moon: Episode 5 The fourth astronaut}}</ref>