association
    Association is the process of creating dynamic links that the OS must go through in order for a program to execute, and resolves every intermodule reference. Details.

Code Server (CS)
    A logical entity that handles requests from clients, be they operating systems or other code servers, and provides them with modules as well as the information necessary to associate the modules (names, locations, and reference lists).

dynamic linking
    Dynamic links allow intermodule linking to be postponed until just before runtime.  In essence, the OS takes over the final stage of program preparation (linking).  The technique of dynamic linking also allows separate compilation and maintenance of individual modules.

explicit dynamic link
    Made when a user program calls an executable by name, e.g. WinExec('foo.exe') or LoadModule('foo.dll').

export
   A target item (e.g. a piece of executable code, variable, or constant) in a module that other modules can link to by address.  Converse of import.

file server
    A machine separate from its clients that handles requests for files and sends them over the network.  A file server is essentially a remote file system, and is almost entirely controlled by its clients.

fixup
    Also known as a relocation item. Fixing up a module requires the address of a target to be written over a victim at a prescribed location in the module being fixed up. If the fixing up takes place after the victim's code file is loaded into memory, but before use of the link, this process is described as dynamic linking.

import
    A target item (e.g. a piece of executable code, variable, or constant) in another module a module links to by address.  Converse of export.

implicit dynamic link
    Made when the OS resolves references to other modules during loading of a program or module.

linker-loader
    Describes an integral component of an OS which performs dynamic linking.  Linker-loaders are closely tied to the executable format which they support.  This format specifies the number and nature of relocations, imports, and exports of a given module.  For Win16 this is the NE (New Executable) format, and for Win32 this is the PE (Portable Executable) format.  The client component  in the Code Server architecture (see Mini Code Server) enhances, and may even replace the linker-loader of an OS.

LoadModule
    The OS routine invoked in Windows to create a dynamic link to a module.  It calls itself recursively to resolve the references of the linked to module first, before creating the link.  It was patched in our Windows implementation to pass control to the Code Server instead of looking for modules directly.

mini Code Server (mini-CS)
    Still a Code Server in its own right, a Mini-CS is entwined with the client's OS and communicates with it and also other
Code Servers on the network.  It is the link between the client and the Code Server network, and also the link between the
client and its file system.  The Mini CS replaces all or part of the linker-loader (see above), and speaks CS protocol and/or makes file calls. This protects the original linker-loader from making real file calls to access executables.

modules
   Programs are often broken into many pieces, each piece being known as a module.  Modules are dynamically linked to each other at runtime, and are the smallest pieces that a Code Server handles. Details.

name space
    The imaginable universe of named objects which could be referred to during linking. In Windows the name space of loadable modules starts at "A" and ends at "ZZZZZZZZ".

New Executable (NE) file format
    The format which Win16 programs require for execution, both EXE's and DLL's. Every NE file has an MSDOS header known as the stub which prints out a message such as "This program requires Microsoft Windows". The contents of the NE header assist in loading and association, and define imports, exports, and code segment characteristics.

operating system (OS)
    An operating system is a program that loads other programs and provides them with a common set of services.  Addition of a Code Server to an OS separates part of the linker-loader so that it can be used across the network.

p-Code (also in Java this is known as bytecode)
    Instructions for a mythical machine, known as a p-machine, are prepared by the language tools into "exceutable" form. A special program called an interpreter then emulates the p-machine by reading the p-codes one at a time, thereby executing the actions they imply. p-Code is very compact compared to native machine code - it also has the advantage of being portable between different CPU types (such as Motorola's and Intel's respective chip families).

Portable Executable (PE) file format
    The format which Win32 programs require for execution, both EXE's and DLL's. Every PE file has a null NE header! The PE header defines similar properties as the NE header, but for 32-bit executables.

protocol
    The method by which two programs or logical entities (e.g. Code Servers) communicate and work together. In the context of the code server patents, the information transmitted by protocol is platform-independent, and must not contain address references.

public-key-encryption
    A means to secure transactions across a network where two keys are used, one belonging to the sender, and one to the receiver, where neither needs to know the other's key.

"Push" technology
    Push technology is a network architecture that allows the broadcast of information, generally on a subscription basis (e.g. the client "subscribes" to a certain page or channel).  This may be news broadcasts, stock market data, etc.  So far, the dream of program distribution by these means has not been realized.  The idea behind Push is fundamentally flawed because clients receive information passively.

"Pull" technology
    Pull is essentially Push in reverse, and is at the heart of the Code Server idea.  Upon an OS file request, a Code Server will attempt to produce it, and could foreseeably use all the Push architecture that has already been developed.  Unlike Push technology, data only arrives at the client computer as a direct result of attempting to run a program or open a file.

reference
    Each module called by the present module has one reference, whether there is one import from the module being called or several.  References are resolved when dynamic links are created.

reference list
    Module references are in a list at a defined location within the code file.  A Code Server can save the reference list of a module, along with its name and location, in a table, so that it doesn't have to be read in from the module again upon subsequent associations of the program.

relocation
    The process of fixing up a module in memory before execution.

static linking
    The process of permanently resolving modules which reference each by binding them into a single larger modules.  This is generally carried out by a linker.  The resulting module may still have external references to other modules which are resolved just prior to runtime by the process of dynamic linking.

target
    An address written over a victim in a module during relocation.  For a dynamic link this is an address, direct, or indirect, of an export from another module. See victim.

victim
    A relocation item in a given module into which is copied the address of a target. For a dynamic link, an import in the file on disk becomes the address, direct or indirect, of an item in another module already loaded.  See target.

virtual machine (VM)
    Windows runs in a single virtual machine, under the control of the VMM. DOS boxes are generally created as separate virtual machines that share the VMM and its resources (services), but do not communicate directly with each other.

Virtual Machine Manager (VMM)
    The 32-bit code loaded before Windows that also manages most low-level drivers in Windows and Windows95. It consists of a number of linked VxD's, and may or may not incorporate other VxD's from separate files (at boot time in Win31, also at run time in Win95).

VxD
    A VMM-level driver.