| |
The heart of any digital computer is the Central Processing Unit (CPU), which performs the work of calculation. It will understand a preset group of instructions (known as ‘op-codes’), to tell it what to do. These op-codes are strings of 0s and 1s. A program, from the point of view of the CPU, is a sequence of these instructions, executed consecutively (taking into account ‘jump’ instructions, which tell it to leave out several instructions). The total set of all possible instructions is called the ‘machine language’.
In essence, the machine language is very simple; there may only be a few dozen different instructions (to ensure that the CPU is cheap, efficient, fast and reliable). It is very powerful; the Turing machine, an even simpler theoretical model of a computer, can do everything that the most sophisticated super-computer can do (though not as fast). The problems of machine language are that the set of instructions understood by the CPU is specific to the make of computer being used, and that it is very difficult, given a machine language program, to understand what it is doing and to change and debug it (remove errors) and, indeed, to write it in the first place.
To overcome these problems ‘assembly language’ is used. Although not very different from machine language, this does solve some of the obvious faults; mnemonics are used instead of binary op-codes, and labels can be used (so that, for example, the exact number of instructions to be skipped by a jump instruction does not have to be calculated beforehand), and so on. Assembly language cannot be directly understood by the CPU; it needs a program (the ‘assembler’) to translate for it.
Assembly language does not move forward very far. One instruction in assembly language represents one instruction in machine language, so that the program will still not be comprehensible to the human user without a lot of special training. This problem is solved by using any one of a large number of higher level languages, in which one instruction can represent many machine language instructions, and which can therefore be made comprehensible to a human user. Common examples of such languages are FORTRAN, BASIC, PASCAL, LOGO and C. In most of these languages, it is possible, given a little ingenuity, to gain some idea of what a program will do with no actual formal understanding of the language itself.
Once again, higher level languages need to be translated so that the CPU can understand them. There are two main methods by which this can be done. An ‘interpreter’ is a program that operates when the program you wish to run (the ‘source’ program) is executed: it translates each instruction one at a time as needed into machine (or assembly) language. This approach takes no account of whether an instruction has been encountered before; it will just translate it again, so that one line of source program may be translated thousands of times. This makes it a slow method of running software. However, it does have the advantage that the full translated version of the program does not need to be stored, so it tends to be the method used when memory space is at a premium. The alternative, a ‘compiler’, takes the source program as a whole and creates a version in assembly language, which can be stored and run at a later date. This means that programs, once compiled, can run much faster. Many compilers ‘optimize’ as they compile the source program, eliminating inefficiencies (caused by the very nature of high level languages) to produce even faster running compiled programs. SMcL |
|
