Computer languages have undergone dramatic evolution since the first
electronic computers were built to assist in telemetry calculations during World
War II. Early on, programmers worked with the most primitive computer
instructions: machine language. These instructions were represented by long
strings of ones and zeroes. Soon, assemblers were invented to map machine
instructions to human-readable and -manageable mnemonics, such as ADD
and MOV.

In time, higher-level languages evolved, such as BASIC and COBOL. These
languages let people work with something approximating words and sentences, such
as Let I = 100. These instructions were translated back into machine
language by interpreters and compilers. An interpreter translates a program as
it reads it, turning the program instructions, or code, directly into actions. A
compiler translates the code into an intermediary form. This step is called
compiling, and produces an object file. The compiler then invokes a linker,
which turns the object file into an executable program.

Because interpreters read the code as it is written and execute the code on
the spot, interpreters are easy for the programmer to work with. Compilers,
however, introduce the extra steps of compiling and linking the code, which is
inconvenient. Compilers produce a program that is very fast each time it is run.
However, the time-consuming task of translating the source code into machine
language has already been accomplished.

Another advantage of many compiled languages like C++ is that you can
distribute the executable program to people who don't have the compiler. With an
interpretive language, you must have the language to run the program.

For many years, the principle goal of computer programmers was to write short
pieces of code that would execute quickly. The program needed to be small,
because memory was expensive, and it needed to be fast, because processing power
was also expensive. As computers have become smaller, cheaper, and faster, and
as the cost of memory has fallen, these priorities have changed. Today the cost
of a programmer's time far outweighs the cost of most of the computers in use by
businesses. Well-written, easy-to-maintain code is at a premium. Easy-
to-maintain means that as business requirements change, the program can be
extended and enhanced without great expense.