threaded code (ITC), for his Forth virtual machine. Moore arrived at this arrangement because Nova minicomputers had an indirection bit in every address, which made ITC easy and fast. Later, he said that he found it so convenient that he propagated it into all later Forth designs. Today, some Forth compilers generate direct-threaded code while others generate indirect-threaded code. The executables act the same either way. Threading models Practically all executable threaded code uses one or another of these methods for invoking subroutines (each method is called a "threading model"). Direct threading Addresses in the thread are the addresses of machine language. This form is simple, but may have overheads because the thread consists only of machine addresses, so all further parameters must be loaded indirectly from memory. Some Forth systems produce direct-threaded code. On many machines direct-threading is faster than subroutine threading (see reference below). An example of a stack machine might execute the sequence "push A, push B, add". That might be translated to the following thread and routines, where ip is initialized to the address labeled thread (i.e., the address where &pushA is stored). #define PUSH(x) (*sp++ = (x)) #define POP() (*--sp) 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: PUSH(A) jump *ip++ // send control where ip says to (i.e. to pushB) and advance ip pushB: PUSH(B) jump *ip++ add: result = POP() + POP() PUSH(result) jump *ip++ Alternatively, operands may be included in the thread. This can remove some indirection needed above, but makes the thread larger: #define PUSH(x) (*sp++ = (x)) #define POP() (*--sp) start: ip = &thread jump *ip++ thread: &push &A // address where A is stored, not literal A &push &B &add ... push: variable_address = *ip++ // must move ip past operand address, since it is not a subroutine address PUSH(*variable_address) // Read value from variable and push on stack jump *ip++ add: result = POP() + POP() PUSH(result) jump *ip++ Indirect threading Indirect threading uses pointers to locations that in turn point to machine code. The indirect pointer may be followed by operands which are stored in the indirect "block" rather than storing them repeatedly in the thread. Thus, indirect code is often more compact than direct-threaded code. The