The Interpreter and Compiler

The first phase of preparing a program for the computer to execute is the entry of the program instructions at an appropriate language level, and this will usually be done with a text editor as already described. The language used to describe the procedure to be followed is almost always quite different from the machine language level. Thus some form of translation from one language level to a lower level is required. In the early days of electronic computers, this was done by hand assembling the machine instructions to execute each high level instruction. One of the first routine tasks to be automated was the process of such a translation, resulting in either an interpreted or a compiled execution environment for the program.

The distinction between the terms interpret and compile arises when we consider that most useful tasks in scientific computing involve highly repetitive instruction sequences, usually called loops of one form or another. For a program which involves significant looping, the process of translating from the high level language to the machine level for each iteration can consume a large fraction of the computer time, while for a program that does not have to execute many repetitive instructions, the cost of interpreting is relatively low.

When efficiency is critical, the compiled language approach is usually better, in part because of the elimination of the repeated translation task after the first cycle through a loop. A further significant improvement to be gained from the compiled approach is that the translation program, usually called the compiler, can be allowed to analyze the whole program, or at least large parts of it, to determine details of its structure which then allow optimization of the program. This usually results in significant improvement in efficiency, without the detailed intervention of the user. This feature cannot be implemented in the interpreted approach, since the interpreter cannot, by its definition, have significant information concerning the global structure of the program.

It is frequently useful to use both the interpreted and compiled approaches during program development, since the interpreted approach allows very fast incremental improvements to the program, which can then be compiled for actual production use. A prime example of such an approach is with the LISP language, where development is done in a LISP interpreted environment, and well tested modules can then be compiled by the LISP compiler and integrated back into the LISP interpreter. This hybrid approach forms the basis of many LISP applications, such as computer algebra systems, to be discussed later. While this approach can be used with languages like C and FORTRAN, there are frequently complications in the transition from interpreted to compiled programs. Of course the BASIC language was initially designed as an interpreted language, and the resulting low performance was later improved by adding the ability for the language to be compiled.

Recently developed languages that have been designed to be interpreted include JAVA, TcL/Tk, PERL, and Python, among others. Some of these languages have been designed from the outset to allow a simpler form of compiling called byte compiling. The target in this form of compiling is not a specific hardware machine, but a simple and well defined intermediate level machine which is a virtual machine. While this virtual machine is not implemented in hardware, its specification is available to software designers, leading to the development of the implementation of the virtual machine on any hardware platform and any operating system. This approach provides many advantages at the possible cost of slightly slower execution. An important influence on the design of these byte-compiled languages is the device-independence required for programs that must run properly on any machine connected to the Internet. A program written and byte-compiled in JAVA, for instance, can be run on any computer and operating system that have the byte-code interpreter specified in the JAVA design. The implementation of this interpreter is the responsibility of the local host computer. This local host can thus control access to its own resources by carefully watching the byte-codes as they arrive, and allowing execution of only those instructions that do not threaten the integrity of the local system. Good design can provide high security from outside attack by hackers, but sloppy design can lead to a computer system that is easy prey for outside hackers.

Hope it will help u

CHEERS!!!