[1] This may not be true eventually, because memories may get large enough so that it would be impossible to run out of free memory in the lifetime of the computer. For example, there are about $3\times 10^{13}$, microseconds in a year, so if we were to pair once per microsecond we would need about $10^{15}$ cells of memory to build a machine that could operate for 30 years without running out of memory. That much memory seems absurdly large by today's standards, but it is not physically impossible. On the other hand, processors are getting faster and a future computer may have large numbers of processors operating in parallel on a single memory, so it may be possible to use up memory much faster than we have postulated.
[2] We assume here that the stack is represented as a list as described in section 5.3.1, so that items on the stack are accessible via the pointer in the stack register.
[3]

This idea was invented and first implemented by Minsky, as part of the implementation of Lisp for the PDP-1 at the MIT Research Laboratory of Electronics. It was further developed by Fenichel and Yochelson (1969) for use in the Lisp implementation for the Multics time-sharing system. Later, Baker (1978) developed a real-time version of the method, which does not require the computation to stop during garbage collection. Baker's idea was extended by Hewitt, Lieberman, and Moon (see Lieberman and Hewitt 1983) to take advantage of the fact that some structure is more volatile and other structure is more permanent.

An alternative commonly used garbage-collection technique is the mark-sweep method. This consists of tracing all the structure accessible from the machine registers and marking each pair we reach. We then scan all of memory, and any location that is unmarked is swept up as garbage and made available for reuse. A full discussion of the mark-sweep method can be found in Allen 1978.

The Minsky-Fenichel-Yochelson algorithm is the dominant algorithm in use for large-memory systems because it examines only the useful part of memory. This is in contrast to mark-sweep, in which the sweep phase must check all of memory. A second advantage of stop-and-copy is that it is a compacting garbage collector. That is, at the end of the garbage-collection phase the useful data will have been moved to consecutive memory locations, with all garbage pairs compressed out. This can be an extremely important performance consideration in machines with virtual memory, in which accesses to widely separated memory addresses may require extra paging operations.

[4] This list of registers does not include the registers used by the storage-allocation system—root, the-heads, the-tails, and the other registers that will be introduced in this section.
[5] The term broken heart was coined by David Cressey, who wrote a garbage collector for MDL, a dialect of JavaScript developed at MIT during the early 1970s.
[6] The garbage collector uses the low-level predicate is_pointer_to_pair instead of the list-structure operation because in a real system there might be various things that are treated as pairs for garbage-collection purposes. For example, in a JavaScript system that conforms to the ECMAScript standard a function object may be implemented as a special kind of pair that doesn't satisfy the is_pair predicate. For simulation purposes, is_pointer_to_pair can be implemented as is_pair.
5.3.2 Maintaining the Illusion of Infinite Memory