Click above to get retro games delivered to your door ever month!

 Benefits of using DLLs
------------------------------------------------------------------------------
 The primary advantages of using DLLs over static link libraries are the
 sharing of code between applications, ease of updating or replacing parts of
 a system, and managing large systems as self contained modules.
 Code used by multiple applications can be stored and used from a DLL rather
 than statically linking the code into each application .EXE, reducing
 redundancy and potentially significantly reducing .EXE size.

 Since DLLs are compiled and linked independently of the applications that
 use them, they can be changed or updated without requiring applications to
 be recompiled or relinked. For example, language-specific code and data can
 be stored in multiple DLLs and the correct one configured at installation
 time, or from within the program, by renaming or copying the appropriate
 DLL.

 If several applications work together as a system and all share common DLLs,
 the entire system can be improved by replacing the common DLLs with enhanced
 versions. A bug fix in one of the DLLs will fix the bug in all applications
 that use it. Likewise, speed improvements or new functionality benefit all
 applications that use the DLLs.

 For a DLL update to work without requiring that the applications that use it
 be updated, the DLL's exported functions must not change their names (if
 exported by name), ordinal numbers, calling conventions, or parameter lists.
 Provided this level of compatibility is maintained, however, the
 application's executable file would not need to be updated at all.

 Code and data, and therefore implementation details, can be hidden from
 applications by placing them in DLLs. By providing a well-defined public
 interface, a DLL can implement an abstract data type (ADT), which can be
 used by applications without their needing to know anything about the actual
 implementation. Changes to the internal code and data structures can be made
 without needing to modify or even recompile the applications that use them.
 A good example of this would be a replaceable database driver with an
 interface of higher level record access functions.

 The most significant disadvantages of DLLs are that they can be more
 difficult to develop, and managing more executables on a disk can be more
 complicated to set up and maintain.

 Because DLLs are not tasks, they do not have their own stacks and must use
 the calling-application program's stack. This often leads to confusion
 because programmers must remember that in DLLs that have their own DGROUP,
 the stack segment is not the same as the data segment. When SS is not equal
 to DS, pointers must be treated carefully to make sure they address the
 proper data in the proper segment. Please see the next section entitled
 'Coding for DLLs' for more details.