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

  In the last chapter, we briefly discussed the general principles of
  building and linking program modules. In this chapter, we're going to
  discuss some specific programming languages. We'll focus on those aspects
  of the languages that you need to be concerned with when you link modules
  written in high-level languages to assembly-language subroutines.

  The title of this chapter implies that we are going to discuss programming
  languages in general, but that's really not the case. It's all very well
  to discuss any topic in the abstract, but to get anything done, you have
  to get down to specifics. If you want to create computer programs, you
  have to work with a specific programming language--and a programming
  language is much more specific than many people are led to believe.

  First of all, there is no such thing as a generic programming language.
  You can create working programs only with a compiler or interpreter for a
  programming language designed for a particular machine. Although academic
  experts on computers would like to pretend otherwise, the general
  definitions of programming languages lack many of the essential features
  that you need to create real programs that work on real computers. So,
  when a compiler or an interpreter is created for a particular programming
  language (such as BASIC) to run on a particular computer (such as the IBM
  PC), the fundamental language is altered and extended to provide specific
  features. The alterations are often quite significant, and in every case,
  they create a programming language that is related to, but distinct from,
  all other programming languages of the same name.

  What we're trying to say is that this chapter does not and could not
  possibly cover every PC programming language that exists or that might be
  created in the future. Because each compiler, in effect, creates a unique
  programming language, we've chosen not to discuss programming languages in
  general. Instead, we will examine several real-world implementations:
  Microsoft/IBM Macro Assembler, Microsoft C, IBM interpreted BASIC,
  Microsoft QuickBASIC, and Borland's Turbo Pascal.