Machine language in a computer is the means through which
a central processing unit is instructed how to pursue a series of operations in
the sensori-motor environment of the central processing unit. Any machine
language presumes a very specific architecture of processor, memory and
sometimes extensional elements, all of which determine this basic sensori-motor
environment; indeed, machine language is the closest discourse mode that one
can enter into with a computer. The general interpretation of machine language
instructions is accomplished through a central processing unit that uses a
program instruction counter to indicate the instruction to be interpreted
(executed) by the central processing unit. A typical architecture will call for
the instruction indicated by the program instruction counter to be interpreted
and then the program instruction counter is updated so that it points at the
next instruction; the full set of instructions is known as a program.
The
sensori-motor experience of a central processing unit can be reduced to the
manipulation of switched binary elements. That is, the computer’s world is
comprised of ones and zeros, and its sensory system is oriented toward
differentiating a one from a zero and subsequently manipulating strings of ones
and zeros. What, one might ask, can be accomplished with such a restrictive
environment? Well, pretty much anything within the realm of human interactions,
because their complete environment can be represented through the metaphorical
manipulation of objects that can in turn be represented by strings of ones and
zeros. In short, a computer must be able to locate the position of a binary
object; tell if it’s a one or a zero; switch to different sets of instructions
based on what the test determines; and, change a one to a zero or a zero to a
one. With this instruction set as the basic lever, one can move the world.
While this seems an ambitious statement, it has been indeed proven that all
computer programs resolve to such a humble origin, called a Turing machine, as we’ve discussed in
Chapter 4.
One of the first
epiphanies for just about anyone that learns computer programming is that of
metaphorical representation and extension. This generally takes the form of a
rather common experience. Mid-way through their first basic programming course,
many people seek to define a number of sub-programs that provide a metaphorical
context for the common programming problems thus far encountered. In other
words, they begin to extract a number of common threads within the problems
that they see and they seek to provide a common programming solution to these
problems. The rather natural assumption is then to believe that these common
solutions will have general utility to others working on the same problems.
Unfortunately, at this stage of their development, most programmers tend to
imbue these solutions to common problems with their own specific way of
thinking; the solutions embody more of the individual person’s cognitive
processes than a common view towards many different problems.
Working in machine
language requires the programmer to identify procedural operations through
binary numeric codes. The addresses of memory locations that contain
information to be accessed and processed by these procedural operations must
also be identified through binary codes. This type of language is fraught with
opportunities for error; it is easy to give the wrong instruction and it is
easy to give the wrong memory address. Consequently, a shift in language
structure towards that of human natural languages is a positive step, even if
it is only a very tiny shift. Such a translation is provided by assembly
languages.
Assembly language is a slightly higher-level language than
machine language. Different assembly languages are typically found for
different computer platforms. Generally, an assembly language is very tightly
coupled to the machine language for a particular processor. It uses slightly
more readable grammar than basic machine language, typically incorporating
mnemonics in place of numeric codes for instructions or parameters.
Consequently, it is significantly easier to be read by
|