> Is there any particular reason you can't do LISP in 18-bits? No, as already [commented][1], LISP can of course be done with any machine word size. It's just that a 36 bit word could hold all elements of a "CONS" (aka pair), the core management object of LISP, **on the computer LISP was developed for** (*1). On a 36 bit machine any access to a list will always retrieve a CONS at once, whereas on an 18 bit machine two fetches are necessary. More so, a 36 bit register does always hold a complete CONS, Both makes a CONS as well atomic within the underlying hardware, all without further ado. > The address space was still 18-bits, so it's not memory size. Its not about address length but encoding. In fact, the usable address space for 36 bit Lisp implementations was only 15 bit, good for 32 KiWords. This was quite fine in 1958 where even a top end computer like the [IBM 704][2] maxed out at 32 KiWords. --- A basic element of a list, a Cons, consists of two pointers: - CAR - pointing to the list item and - CDR - pointing to the next list entry A pointer needs to be qualified, as it may point to another list(CONS), or a leaf (ATOM). It a few bits are needed to be added to each pointer. Now, the original LISP was developed on an IBM 704, a computer with 36 bit word size and 15 bit address size. Which not only gave nicely room to hold two 15 bit address pointers plus the needed qualifiers, but had already instructions for easy access of these fields. - 3 bits Prefix qualifier (CPR) - 15 bits Decrement address (CDR) - 3 bits Tag qualifier (CTR) - 15 bits Address address (CAR) In fact, LISP is way more tied to the 704 machine structure than one may expect, as these 4 fields are what a type A instruction looks like: - 3 bit Prefix, the instruction - 15 bit Decrement, an index to be used (*2) - 3 bit Tag, selecting one or more index registers to be used - 15 bit Address Does quite look like a CONS, doesn't it? This was noted by the developers of the first implementation. Moreso as the 704 offered instructions to direct read or write (*3) each of these fields within a register. Almost as if the 704 was on purpose constructed to support Lisp (*4). Lisp was implemented using a set of Assembly language macros (*5) to access the fields within a CONS element: CPR, CDR, CTR and CAR. Everything else was constructed from there. CAR and CDR survived into later Lisp lingo as shorthand for the elements of a CONS. Using this structure made CONS atomic machine words and allowed not only easy accessed and use of both pointers, but it was also quite compact and performant. Later, non 704/709x based, 36 bit implementation had to use shift and masking operation to do the same. loosing the performance advantage, but still kept the atomic nature of a CONS. And yes, all of this can be of course be done as well on an 18 bit machine. Except now a CONS will cover two (18 bit) words, effectively halving the available memory as now only even addresses are valid - or each and every access will need to include a shift operation to turn a CONS address into a memory address (*6). Like so often it's not about an implementation being impossible, or the difference being huge, but the little advantage that will pay out big when done often enough - like with every access or [iteration][3]. --- *1 - And was still good for quite some time after. *2 - Called Decrement as index values would be subtracted from a base address *3 - Tag write was never implemented *4 - Which may as well be part of the impression that Lisp is especially good on 36 bit (704) tpe machines. *5 - The first implementation was in Assembly, what else? *6 - Which might be not as much of an additional burden as the address had to extracted by masking anyway. [1]: https://retrocomputing.stackexchange.com/questions/24867/was-36-bits-needed-for-lisp#comment82608_24867 [2]: https://en.wikipedia.org/wiki/IBM_704 [3]: https://retrocomputing.stackexchange.com/a/24860/6659