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

  As with any programming language, you can use assembly language in two
  different ways: to write stand-alone programs and to write subroutines
  that can be called by other programs. Subroutines depend largely on the
  calling program to provide their structure and support, but a stand-alone
  assembly-language program must provide its own structure and support and
  must cope with all the fundamental operating issues that stand-alone
  programs face. Assembler subroutines are relatively easy to construct, but
  stand-alone assembler programs can be quite complicated. Subroutines have
  more immediate appeal to those who need to build interface routines
  between a high-level language and some of the system's ROM BIOS or DOS
  services, but stand-alone programs appeal to programmers who must
  accomplish a task that neither conventional programming languages nor
  system services provide.

  In this brief discussion of assembly language, we'll demonstrate
  techniques that will help you figure out the high-level-language interface
  conventions for your assembly-language subroutines. We'll also lead you
  through the process of creating a stand-alone assembler program. However,
  we will not even try to teach you how to use assembly language--that is
  far too large and complex a subject.

  If you are not particularly proficient at assembly language, one way to
  learn about it is to study some of the readily available sources of
  assembly-language coding. One place to look is in the ROM BIOS listings
  that are part of IBM's technical reference manuals. Another source,
  available with most compilers, is the assembler-like listing that many
  compilers can be asked to produce. This is useful both for learning how
  the compiler handles particular coding problems (which you can control by
  selecting appropriate statements in the high-level language) and for
  learning the subroutine interface conventions the compiler uses. A
  related, but less useful, way to learn about assembly language is to load
  an existing program using the DOS DEBUG program and then use DEBUG's U
  (Unassemble) command to look through sections of the program. Each method
  can help you learn different programming techniques and tricks.