Language Translators

A processor (CPU) can only directly execute machine code — the binary instructions belonging to its own instruction set. But programmers do not write in raw binary; they write in:

• assembly language — low-level, with mnemonics like LDD, ADD, OUT (one step up from machine code), or
• a high-level language — English-like keywords like if, while, print (e.g. Python, Java).

Neither of these can be run by the CPU as written, so a translator must convert the source code (what the programmer writes) into object/machine code (what the CPU can run).

The three translators in 9618 do this job in different ways — covered next.

Assembly language is a low-level language. It is processor-specific and uses short mnemonics that stand for individual machine instructions. It is used when a programmer needs fine control over the hardware or very efficient code.

An assembler is the translator that converts an assembly-language program into machine code. Because each assembly instruction maps onto (roughly) one machine-code instruction, the translation is essentially one-to-one.

	Assembler
Input	Assembly language (low-level mnemonics)
Output	Machine code
Relationship	Roughly one machine instruction per assembly instruction

Do not confuse the assembler with a compiler: a compiler translates a HIGH-LEVEL language, while an assembler translates ASSEMBLY language.

High-level languages can be translated in two different ways.

A compiler translates the WHOLE program into object/machine code in one go, BEFORE the program is run. The result is an executable file that can be run on its own — the original source code is not needed to run it. A compiler checks the entire program and reports all the errors it finds at the end of compilation.

An interpreter translates AND executes the program one statement (line) at a time. It does not produce a separate executable; the interpreter must be present every time the program is run. If it meets an error, it stops at that statement and reports it, so the program runs only up to the first error.

A useful mental model:

• Compiler = translate the whole book first, then read the (translated) book aloud later.
• Interpreter = translate each sentence out loud as you go — and stop at the first sentence that doesn't make sense.

Here is the comparison the exam wants you to reproduce:

Point of comparison	Compiler	Interpreter
When translation happens	Whole program translated before execution	Translated and executed one line at a time
Error reporting	Reports all errors at the end of compilation	Stops at the first error
Output produced	A standalone executable (object/machine code)	No executable; interpreter needed each run
Execution speed	Faster — already machine code	Slower — retranslated each run (and each loop pass)
Source code needed to run?	No — distribute only the executable	Yes — source + interpreter needed each time
Best suited to	Finished/distributed software	Development and debugging

How to justify a choice (the high-value skill):

• Still writing and debugging a program? Choose an interpreter — it stops at the first error so bugs are easy to find, and there is no recompilation step, so each change can be tested immediately. Slow execution doesn't matter during development.
• Selling finished software? Choose a compiler — it gives a fast, standalone executable; the source code is not distributed (so it can't easily be read/changed); and the customer needs no translator installed to run it.

Always pin each reason to the context in the question. A bare "use an interpreter" earns one mark at most.

Some high-level languages are both compiled and interpreted. Java (in console mode) is the standard 9618 example.

It works in two stages:

1. Partially compiled: the Java compiler translates the source code into an intermediate form called bytecode. Bytecode is not the machine code of any one processor — it is platform-independent.
2. Partially interpreted: when the program runs, the Java Virtual Machine (JVM) interprets (or just-in-time compiles) the bytecode into the machine code of the actual computer, statement by statement.

Benefit: the same bytecode runs on any device that has a JVM — write once, run anywhere (portability), without recompiling for each kind of computer.

Drawback: running bytecode through the JVM is generally slower than running fully compiled native machine code, and a JVM must be installed for the program to run.

An Integrated Development Environment (IDE) is one program that bundles together everything needed to write, test and debug code. Its features fall into four syllabus groups:

Coding

• Context-sensitive prompts / auto-complete: as you type, the IDE suggests valid keywords, variable names and parameters — faster coding and fewer typing errors.

Initial error detection

• Dynamic syntax checks: syntax is checked as the code is written, highlighting errors (e.g. a missing bracket) immediately rather than waiting until compile/run time.

Presentation

• Prettyprint: code is automatically formatted and indented, making it easier to read.
• Expand / collapse code blocks: sections (loops, functions) can be folded away, making large programs easier to navigate.

Debugging (finding logic errors while the program runs)

• Single stepping: runs the program one statement at a time so you can follow the exact flow of execution.
• Breakpoints: pause execution at a chosen line so the program's state can be inspected at that point.
• Watch window (watch variables/expressions): displays the live values of chosen variables/expressions as the program runs.
• Report window: shows debugging output/messages from the run.

In the exam, name a feature and say how it helps — the marks are for the benefit, not the label.