Show understanding of the need for: a compiler for the translation of a high-level language program

5.2 Language Translators – The Need for a Compiler

1. Why translate a high‑level program?

High‑level languages (e.g., Java, C++, Python) are designed for human readability and

productivity. A computer, however, can only execute machine code – binary instructions

that correspond directly to the processor’s instruction set architecture (ISA). Therefore,

a program written in a high‑level language must be translated into machine code before it

can run.

Translation also provides:

• Portability – the same source can be compiled for different hardware.
• Optimization – the compiler can improve performance and reduce resource usage.
• Safety – static type checking and other analyses catch many errors before execution.

2. What is a compiler?

A compiler is a language translator that reads an entire high‑level program, analyses it,

and produces an equivalent program in a lower‑level language, usually machine code or

assembly language. The translation is performed once, producing an executable that can be

run repeatedly without further translation.

3. Compilation versus interpretation

The two main approaches to executing high‑level programs are:

1. Compilation – translate the whole program before execution.
2. Interpretation – translate and execute statements one at a time at run‑time.

The table below summarises the key differences.

4. Stages of a typical compiler

A compiler is usually divided into distinct phases, each responsible for a specific

transformation of the source program. The main phases are:

1. Lexical analysis (Scanning) – converts the character stream into tokens.
2. Syntactic analysis (Parsing) – builds a parse tree according to the language grammar.
3. Semantic analysis – checks type consistency, scope rules, and other language semantics.
4. Intermediate code generation – produces a platform‑independent representation (e.g., three‑address code).
5. Optimization – improves the intermediate code (e.g., dead‑code elimination, loop unrolling).
6. Target code generation – translates the optimized intermediate code into assembly or machine code.
7. Assembly and linking – assembles object files and resolves external references to produce the final executable.

5. Why a compiler is essential for high‑level languages

The following points illustrate the necessity of a compiler:

• Performance – Compiled code runs at near‑hardware speed. For algorithms with time complexity \$O(n \log n)\$, the constant factors introduced by interpretation can make a practical difference.
• Resource constraints – Embedded systems often lack the memory or processing power to host an interpreter, making a pre‑compiled binary the only viable option.
• Distribution – End users typically receive executables, not source code, protecting intellectual property and simplifying deployment.
• Static analysis – Compilers can perform extensive checks (type safety, unreachable code) before the program ever runs, reducing runtime failures.

6. Summary

A compiler bridges the gap between human‑friendly high‑level languages and the low‑level

instructions a computer can execute. By translating the entire program ahead of time,

compilers provide speed, safety, and portability that are essential for many real‑world

applications, especially where performance and resource usage are critical.