Differences Between Translators

Different routes from source code to execution

A processor executes machine code: instructions encoded in binary. A programmer usually writes source code in a more readable language. An assembler, compiler or interpreter bridges the gap between those written instructions and the operations performed by the processor, but they do not all work in the same way.

The important distinction is between producing machine code for later execution and carrying out source-code statements as the program runs.

Assemblers: one instruction becomes one instruction

Assembly language is a low-level language. It uses short mnemonic names to represent machine instructions, rather than requiring the programmer to write those instructions in binary.

An assembler translates assembly language directly into machine code. Each line containing an assembly-language instruction is assembled into one machine-code instruction. This one-to-one relationship reflects how closely assembly language matches the processor's instructions.

For example, an assembly-language instruction telling the processor to perform an addition becomes the corresponding machine-code instruction. The assembler produces that instruction; the processor executes it when the resulting program runs. Translation and execution are separate stages.

Compilers: translate the program before running it

A compiler takes a high-level program and translates the whole program directly into machine code before execution. The resulting compiled program can then run without the compiler being present.

Unlike assembly language, high-level code does not have a one-to-one relationship with machine instructions. A single high-level statement can describe a task that needs several machine-code instructions to carry out.

For example, a statement that calculates a value and displays it may require several processor operations. The compiler produces the machine code needed for those operations as part of translating the program. It does not execute each source statement immediately after translating it.

If the programmer changes the source code, it must be compiled again for those changes to appear in the compiled program.

Interpreters: carry out statements as the program runs

An interpreter works through high-level source code one statement at a time, carrying out each statement before moving on to the next statement to be executed. Interpretation and execution therefore happen together, rather than producing a separate machine-code program first.

Crucially, an interpreter does not generate machine code directly. Its own code contains appropriate, already compiled machine-code subroutines: routines that perform particular tasks. When the interpreter encounters a source statement, it calls the routines needed to carry it out. The processor executes those routines.

For example, when a statement requests a calculation and output, the interpreter calls suitable routines to perform those tasks. This explains how an interpreted program can run even though the interpreter does not directly turn each statement into a new machine-code instruction.

The interpreter is needed whenever the source program runs. It processes the statements again on each run, rather than leaving behind a separately compiled executable. If it encounters an error that prevents it from continuing, execution stops at that point.

The two translation routes produce machine code from the input program. The interpretation route instead uses machine code already within the interpreter to carry out the source statements.