Compiler, Interpreter and Other Computer Science Terms

Computer science terminology is central to understanding how programming languages are written, checked and converted into instructions a computer can execute. For Prelims revision, the key distinction is between tools that translate code and the rules that define whether code is written correctly and meaningfully.

Core Translation Tools

Translators convert high-level programming language code into machine-readable binary code that processors can execute directly. The three most basic translation tools are compilers, interpreters and assemblers.

• Compiler: A compiler translates the entire high-level source code into machine code in one batch before execution. It typically generates an independent executable file that can run multiple times without requiring the original source code or the compiler again.
• Compilation phase: A compiler scans the whole code before producing output and reports syntax and structural errors together.
• Examples of compiled languages: C, C++ and Rust.
• Interpreter: An interpreter translates source code line by line into machine code during runtime execution. It executes each statement immediately after translation and does not produce a standalone executable file.
• Error handling in interpreters: It stops at the first error, which often makes debugging easier for beginners.
• Examples of interpreted languages: Python, JavaScript and Ruby.
• Assembler: An assembler translates low-level assembly language code into machine-readable binary object code.
• Architecture-specific use: It is designed for specific processor architectures such as x86 or ARM.

Syntax and Semantics

Writing code is not only about logic; it also requires strict rules of structure and meaning. Two standard terms used in this context are syntax and semantics.

• Syntax: The set of grammatical rules and formatting constraints governing how code is written.
• Purpose of syntax: It helps the compiler or interpreter parse code tokens correctly.
• Syntax checking: It verifies whether keywords, punctuation, brackets and indentation follow the formal grammar of the language.
• Syntax error: A violation of syntax rules produces an error message during compilation or interpretation and prevents program execution.
• Semantics: The set of rules that determine the logical meaning and behavior of valid code statements.
• Purpose of semantics: It ensures the computer performs the intended operation during execution.
• Semantic checking: It tests whether properly formed code statements make logical sense in the program context.
• Examples of semantic errors: Adding a string to an integer or using an undeclared variable.

Syntax checks whether code is written correctly; semantics checks whether the code means what the programmer intends.

How Code is Processed

Different translation systems handle code differently, but they all aim to convert human-readable instructions into a form the machine can execute. A few additional terms are especially important in basic programming concepts.

• Machine code: The binary form directly understood by the computer processor.
• Source code: The original human-readable program written in a high-level language.
• Object code: The machine-readable output produced by an assembler or compiler stage.
• Compile-time: The stage when code is translated before execution.
• Runtime: The stage when the program is actually running.
• Syntax errors: These are generally caught during compile-time.
• Semantic errors: Some may appear only during runtime, depending on the program and language.

Important Concepts in Compilation

Some modern languages and execution models combine features of both compilation and interpretation. These terms often appear in exam questions on programming basics.

• Just-In-Time (JIT) compilation: Combines elements of compilers and interpreters by translating bytecode into native machine code during execution to improve performance.
• Python translation model: Python uses a two-step process in which source code is first compiled into intermediate bytecode before being processed by the Python virtual machine interpreter.
• Static type checking: Variable types are evaluated during compilation.
• Dynamic type checking: Variable types are evaluated during runtime execution.
• Debugging advantage of interpreters: Since execution stops at the first error, programmers can identify problems step by step.
• Independent executable: A key feature of compiled code is that it can often be run again without the source code or compiler.

Python is often cited as an example of a language that first compiles source code into bytecode and then executes it through an interpreter.

Key Prelims Takeaways

• Compiler: Translates the whole program at once and usually creates an executable file.
• Interpreter: Translates and executes code line by line during runtime.
• Assembler: Converts assembly language into machine-readable object code.
• Syntax: Relates to the form and grammar of code.
• Semantics: Relates to the meaning and logical effect of code.
• Syntax error: Caught when language rules are violated.
• JIT compilation: Translates bytecode during execution for better performance.