When a program is started, the OS needs to create some way of using the code in the program.  It does this by creating a pointer to the code.

Absolute References:
An absolute reference exists when a module always points to exactly the same place in memory. For example: a pointer to a global variable from the BIOS or OS, or a memory-mapped piece of hardware.

Static Linking:
Certain programs are written in several pieces, with links to other pieces.  However, after compilation, they are permanently linked by a linker into one module, and the links are referred to as static.  In the drawing, A - D are components of a program statically linked to form PROG.EXE.  Static links are pointers within the code that point to the same places relative to each other no matter where the module is loaded.  When a program consists of only one module, that module may be read directly into memory and executed.  Legacy systems such as DOS use only statically-linked programs.  There may be static links within the individual modules of a dynamically-linked system.

Dynamic Linking:
In modern systems (e.g. Windows) that use dynamic linking, the OS must somehow manage all the pieces of a program.  If they don't all fit into memory at once, at the very least the system needs to allocate some memory tables which enable on-demand loading of program code (and optionally data).  Instead of pointing directly to the code in question, as with a static link, a dynamic link points indirectly to a module, be it through a table of code handles or a fixup section of the module.  This means that the referenced module need not be read into memory until the link is used (whereas with static linking everything is read in as one big image).  All that must remain in memory are the pointers that make up the tables, and not even those if fixups are used.  When a dynamic link is written into the referencing module it is known as a fixup.

The 3 Steps of Dynamic Linking:
    1. a program/OS tries to explicitly link to a module
    2. that module gets associated and implicit links are created
    3. the explicit link is returned, along with all the associated implicit links

Association:

When a dynamic link to module is created (its name and location are stored somewhere that any module can access to get to it), the reference list is also examined.  Every single reference in the list is resolved through creation of implicit dynamic links, and the process is recursive.  The recursion stops when a given module has no unresolved references, and the program is fully associated when the dynamic linking falls out of the recursion altogether.  Every module that the program will ever need is now accessible through the dynamic links, and the OS holds on to these links, keeping track of where the modules are, until execution is complete.

Flowchart for Conventional Dynamic Linking

Association MUST Finish Before Execution Commences:
 

Completion of association assures that all of the modules required by a program exist and are accessible.  Intuitively one might conclude that it would be all right only to resolve the modules in a reference list - in the diagram all the B's - before execution, but if the reference list of one of these modules is unresolvable then the program may crash.

Look at the diagram.  Fully associated would mean that every module up to D3 had its references resolved (via implicit dynamic links).  If one tried to execute A at the state shown, and associate the B's when A called them, the program might crash if one of the C's could not be found.  A scary situation would be where A opens a file, B2 modifies it, but C3 - the CloseFile module - does not exist and the program crashes with the file still open.  Having A fully associated would prevent the file from ever being opened in the first place if C3 was unavailable.

There might even be a whole network of modules hiding behind a simple reference, as indicated by the diagram.  Also, if one of the modules is updated - perhaps by another program - and acquires a new reference list, an association that worked one day will not work the next.  Hence saving the results of an association isn't much good either, unless you go through and check all the modules.

So the OS lays down tables (dynamic links) which eventually get filled as each module is called into memory.  Just as with static linking, the whole thing MUST fail if all the pieces cannot be found.