Show awareness that high-level language programs may be partially compiled and partially interpreted, such as Java (console mode)

5.2 Language Translators

Learning Objective

Show awareness that high‑level language programs may be partially compiled and partially interpreted (e.g., Java in console mode) and understand why different types of translators are used.

Why Do We Need Translators?

Translators bridge the gap between the way programmers write code and the way a computer executes it. The three core motivations are:

• Execution speed – compiled code runs directly on the processor, giving the fastest possible performance.
• Portability – interpreted or partially compiled code can run on many different hardware platforms without recompilation.
• Development convenience – interpreters allow rapid testing and debugging because a separate build step is not required.

Each type of translator (assembler, compiler, interpreter, hybrid) favours a different balance of these motivations.

Key Translator Types

• Assembler – Translates assembly language (a symbolic representation of machine instructions) into machine code.

          MOV AX, 5      ; load the value 5 into register AX
  ADD AX, BX     ; add the contents of BX to AX

  The assembler converts the mnemonics into the binary op‑codes that the CPU executes.

• Compiler – Translates an entire high‑level source program into target code (usually machine code) before execution. The output is a standalone executable that can be run repeatedly without further translation.
• Interpreter – Reads the source program (or an intermediate form) line‑by‑line and executes each statement immediately, translating on the fly.
• Hybrid (partial compilation + interpretation) – First compiles source code into an intermediate representation (e.g., bytecode). At run‑time a virtual machine may interpret this representation, and may also just‑in‑time (JIT) compile frequently executed sections into native code.

Benefits & Drawbacks

Hybrid Approach – Case Studies

Java (Console Mode)

1. Source: .java files written by the programmer.
2. Compilation: javac produces .class files containing bytecode – an intermediate, platform‑independent representation.
3. Loading: The Java Virtual Machine (JVM) loads the bytecode.
4. Interpretation: Bytecode that has not yet been optimised is interpreted directly.
5. Just‑In‑Time (JIT) compilation: Frequently executed (“hot‑spot”) bytecode is compiled to native machine code while the program runs, improving performance.

The overall execution time can be expressed as:

Execution Time = Interpretation Time + JIT Compilation Time

Other Languages Using a Hybrid Model

• Python (CPython) – Source → .pyc bytecode → Python virtual machine interprets; optional JIT projects (e.g., PyPy) add runtime compilation.
• C# / .NET – Source → C# compiler produces Microsoft Intermediate Language (MSIL) → Common Language Runtime (CLR) interprets MSIL and JIT‑compiles hot methods to native code.
• Ruby (MRI) – Source → YARV bytecode → virtual machine interprets; alternative implementations (e.g., JRuby) run on the JVM and benefit from its JIT.

Typical Workflow for a Java Console Application

1. Write MyProgram.java.
2. Compile: javac MyProgram.java → creates MyProgram.class.
3. Run: java MyProgram → JVM loads the class file.
4. JVM interprets bytecode; as methods are called repeatedly, the JIT compiler may translate them to native code.
5. When the program ends, any JIT‑generated native code is discarded.

Implications for Developers

• Performance tuning – focus on “hot‑spot” methods that the JIT is likely to optimise.
• Warm‑up period – code may run noticeably faster after a short warm‑up as the JIT compiles frequently used sections.
• Debugging – line numbers map to source, but JIT‑compiled frames can make stack traces harder to read; most IDEs provide options to view both interpreted and compiled frames.

IDE Features Relevant to Translators

• Syntax highlighting – colour‑codes language constructs, making errors easier to spot.
• Real‑time error detection – the IDE’s parser flags syntax errors before compilation.
• Code completion / auto‑suggest – suggests class names, methods, and variables as you type.
• Integrated build tools – one‑click compile/run (e.g., Eclipse “Run” button invokes javac then java).
• Debugging facilities – breakpoints, step‑over, variable inspection; works with both interpreted and JIT‑compiled code.
• Refactoring tools – rename, extract method, and other transformations that keep source and compiled artefacts in sync.

Links to Other Syllabus Sections

• Section 16.2 – System Software: role of operating systems in managing compiled and interpreted programmes.
• Section 20 – Programming Paradigms: why certain paradigms (e.g., object‑oriented) are often paired with specific translation strategies.
• Section 22 – Virtual Machines & Runtime Environments: deeper study of the JVM, CLR, and Python VM.

Quick Checklist for Teachers (Ensuring Full Syllabus Coverage)