What is a Translator?

A translator is a program that converts source code written in one language into another form (typically machine code or an intermediate form) so it can be executed by the CPU. There are three main types relevant to OCR H446: compilers, interpreters, and assemblers.

The Assembler

An assembler translates assembly language into machine code (binary). Each assembly instruction maps one-to-one to a machine code instruction. The assembler works in two passes:

• First pass: scans the entire code to build a symbol table — a mapping of all label names to their memory addresses. This resolves forward references (labels used before they are defined).
• Second pass: converts each mnemonic to its binary opcode and replaces label names with their actual binary addresses from the symbol table.

Output: an object file containing machine code, ready to be linked and executed.

The Compiler

A compiler translates an entire high-level language source program into machine code (or an intermediate language) all at once, before the program runs. The output is a standalone executable file.

Stages of Compilation

• Lexical analysis: the source code is broken into tokens (individual meaningful units: keywords, identifiers, operators, literals). Comments and whitespace are removed. A symbol table is built recording variable names, types, and memory locations.
• Syntax analysis (parsing): tokens are checked against the grammar rules of the language. A parse tree (or abstract syntax tree) is built representing the program's structure. Syntax errors are reported.
• Semantic analysis: the parse tree is checked for meaning — e.g. type checking (can you add an integer to a string?), undeclared variables, incorrect function call arguments. Semantic errors are reported.
• Code generation: machine code (or intermediate code) is generated from the syntax tree.
• Code optimisation: the generated code is analysed and improved for efficiency — removing redundant instructions, optimising loops, reducing memory usage. Happens before or after code generation.

Advantages of a Compiler

• The compiled executable runs very fast — no translation overhead at runtime.
• The executable can be distributed without the source code — protects intellectual property.
• All errors are found before the program runs — a complete list of errors is produced.
• Code optimisation can significantly improve performance.
• The compiled file can run on any compatible machine without needing the compiler installed.

Disadvantages of a Compiler

• The compilation process takes time — development is slower because the programmer must compile before running.
• The compiled executable is platform-specific — must recompile for each target OS/architecture.
• Errors are only found after compilation of the whole program — large programs may take time to compile.
• Debugging can be harder — the error messages relate to compiled code, not always the original line.

The Interpreter

An interpreter translates and executes high-level language source code line by line (or statement by statement) at runtime. Unlike a compiler, it does not produce a separate machine code file — it translates and immediately executes each statement, then moves to the next.

Advantages of an Interpreter

• Errors are reported immediately at the line where they occur — easier for debugging during development.
• No separate compilation step — faster to test and iterate on small programs during development.
• Programs are portable — the same source code runs on any platform that has the interpreter installed.
• Good for scripting, REPL environments (Read-Eval-Print Loop), and interactive development.

Disadvantages of an Interpreter

• Slower execution — translation happens at runtime; each line must be re-translated every time it is executed (e.g. inside loops).
• The source code must be present to run the program — intellectual property is exposed.
• An interpreter must be installed on the target machine.
• Errors are found only when the interpreter reaches the line — errors in rarely-executed branches may not be caught during testing.

Compiler vs Interpreter: Full Comparison

Just-In-Time (JIT) Compilation

Some modern language environments (e.g. Java's JVM, Python's PyPy, JavaScript V8 engine) use a hybrid approach called Just-In-Time (JIT) compilation:

• The source code is first compiled to an intermediate bytecode (not full machine code).
• At runtime, a JIT compiler identifies hot paths (frequently executed code) and compiles them to native machine code during execution.
• This combines the portability of interpretation with the speed of compilation for frequently-run code.

Java: source (.java) → compiler → bytecode (.class) → JVM interprets/JIT compiles → native machine code.