single variation is "best" for all situations. Development To save space, programmers squeezed the lists of subroutine calls into simple lists of subroutine addresses, and used a small loop to call each subroutine in turn. For example, the following pseudocode uses this technique to add two numbers A and B. In the example, the list is labeled thread and a variable ip (Instruction Pointer) tracks our place within the list. Another variable sp (Stack Pointer) contains an address elsewhere in memory that is available to hold a value temporarily. start: ip = &thread // points to the address '&pushA', not the textual label 'thread' top: jump *ip++ // follow ip to address in thread, follow that address to subroutine, advance ip thread: &pushA &pushB &add ... pushA: *sp++ = A // follow sp to available memory, store A there, advance sp to next jump top pushB: *sp++ = B jump top add: addend1 = *--sp // Pop the top value off the stack addend2 = *--sp // Pop second value off the stack *sp++ = addend1 + addend2 // Add the two values together and store the result on the top of the stack jump top The calling loop at top is so simple that it can be repeated inline at the end of each subroutine. Control now jumps once, from the end of a subroutine to the start of another, instead of jumping twice via top. For example: start: ip = &thread // ip points to &pushA (which points to the first instruction of pushA) jump *ip++ // send control to first instruction of pushA and advance ip to &pushB thread: &pushA &pushB &add ... pushA: *sp++ = A // follow sp to available memory, store A there, advance sp to next jump *ip++ // send control where ip says to (i.e. to pushB) and advance ip pushB: *sp++ = B jump *ip++ add: addend1 = *--sp // Pop the top value off the stack addend2 = *--sp // Pop second value off the stack *sp++ = addend1 + addend2 // Add the two values together and store the result on top of the stack jump *ip++ This is called direct threaded code (DTC). Although the technique is older, the first widely circulated use of the term "threaded code" is probably James R. Bell's 1973 article "Threaded Code". In 1970, Charles H. Moore invented a more compact arrangement, indirect