Program Compiler and Program Interpreter - Computer Software, Computer Awareness

Introduction

When we write a program using languages such as C, C++, Java or Python, the text we type is called source code. A computer's processor cannot execute source code directly because it understands only machine language (binary instructions). The process of converting source code into a form the computer can run is done by two main kinds of system software: compilers and interpreters. This chapter explains what each does, how they work, their advantages and limitations, and how they differ in practice.

Program Compilation

A compiler is a program that translates source code written in a high‐level programming language into machine code or an intermediate code that can be executed by a computer. The act of translation performed by a compiler is called compilation.

• Output of a compiler: native machine code (binary) such as a Windows .exe or UNIX a.out, or an intermediate format such as Java bytecode (.class files).
• Whole-program translation: a typical compiler reads the entire source (or modules) and translates them into an executable file before execution.
• Error detection: compilers perform syntax and many semantic checks during translation and report compile‐time errors.
• Optimisation: compilers apply optimisations to improve runtime speed and reduce memory use; optimisation may be at source, intermediate or machine‐code level.
• Independence at run time: once compiled, the executable runs without the compiler being present.
• Need to recompile: if the source code changes, the affected parts (or the entire program) must be recompiled to produce an updated executable.
• Typical languages: C, C++, Rust, Go and many system-level languages are commonly compiled to native code.

Phases of Compilation

1. Preprocessing: handles directives such as #include and macro expansion (C/C++).
2. Lexical analysis: the source text is split into tokens (identifiers, keywords, literals, operators).
3. Syntax analysis (parsing): tokens are checked against language grammar to build a parse tree or abstract syntax tree (AST).
4. Semantic analysis: type checking, scope resolution, and other semantic rules are enforced.
5. Intermediate code generation: an internal representation of the program is produced for optimisation.
6. Optimisation: transformations are applied to the intermediate code to improve performance or reduce resource use.
7. Code generation: the intermediate code is translated into assembly or machine code for a target architecture.
8. Assembly & linking: assembler produces object files; a linker combines object files and libraries into a final executable.

Examples and Notes

• gcc compiles C programs to native machine code (on Linux typically creating an a.out or named executable).
• Java is compiled by javac into bytecode (.class), which is platform independent; the bytecode is executed by the Java Virtual Machine (JVM).
• Advantages of compiled programs: generally faster at runtime and can access low‐level system or hardware features; suitable for large software and performance‐critical applications.
• Disadvantages: compilation time can be significant; executables are platform dependent (unless an intermediate, portable format is used).
• Relevance to engineering disciplines: compiled languages are widely used where performance and direct hardware access are required - for example, embedded systems in Electrical Engineering, numerical simulation in Civil Engineering, and system software in Computer Science.

Program Interpreter

An interpreter is a program that reads source code (or another high‐level representation) and executes it directly, translating and running it statement by statement or construct by construct without producing a separate standalone native executable file.

• Direct execution: interpreters parse and execute code on the fly; common interpreters are those for Perl, Python, and Ruby.
• Single-step processing: interpreters perform lexical analysis, parsing, and execution in a single runtime pass or in small incremental passes.
• Useful for scripting: interpreters are convenient for writing and running scripts, quick tests, and programs that change frequently because there is no separate compile step to perform before running.
• REPL support: many interpreted language implementations offer a REPL (Read-Eval-Print Loop) that aids rapid development and debugging.
• Portability: interpreted source code can run on any platform that has the appropriate interpreter installed.
• Dependency: interpreted code requires the interpreter at run time; without it the source remains plain text and not an executable program.
• Limitations: interpreted programs are typically slower than compiled native code and may have restricted access to low‐level system or hardware features compared with compiled programs.
• Examples: executing a Python script with the command python script.py runs the program under the interpreter without producing a separate binary.

Hybrid and Advanced Approaches

• Bytecode and virtual machines: some languages (for example, Java and C#) use a hybrid approach - source is compiled into portable bytecode which is then interpreted or JIT‐compiled by a virtual machine.
• Just‐In‐Time (JIT) compilation: modern interpreters or virtual machines use JIT to compile frequently executed code paths into native code at runtime, improving performance (examples: Java HotSpot, V8 for JavaScript, PyPy for Python).
• Trace and dynamic optimisation: runtime systems can profile program behaviour and perform optimisations dynamically based on actual execution patterns.

Difference between Interpreter and Compiler

• Translation vs execution: a compiler translates the whole program into machine code before execution; an interpreter translates and executes the program step by step at run time.
• Output: compilers produce a separate executable file; interpreters do not produce a standalone executable (unless a separate packaging step is used).
• Execution speed: compiled code generally runs faster; interpreted programs are usually slower unless JIT compilation or other optimisations are used.
• Error detection: compilers detect many errors at compile time and report them before running; interpreters detect and report errors at the point of execution.
• Portability: interpreted programs are portable across systems with the same interpreter; compiled programs are platform dependent unless compiled to an intermediate portable format.
• Use cases: compilers are preferred for system software, high‐performance applications and embedded systems; interpreters are preferred for scripting, rapid prototyping, educational use, and interactive tasks.
• Development cycle: interpreted languages allow quicker edit‐run cycles; compiled languages may require longer build times but often provide better runtime performance.
• Access to system/hardware: compiled programs can more easily access low‐level system and hardware interfaces; interpreted programs may be restricted by the runtime environment.
• Hybrid cases: languages and environments often combine techniques (bytecode + VM, interpreter + JIT) to get benefits of both approaches.

Practical Examples

• C program: source written in C is compiled by gcc to a native executable that runs directly on the processor.
• Python script: source is interpreted by the Python interpreter; the same script can run on any machine with a compatible Python interpreter installed.
• Java: source is compiled into bytecode which is portable; the JVM interprets or JIT‐compiles the bytecode to native code at run time.

Summary and Applications

Compilers are used where performance, resource efficiency and direct hardware access are required - examples include operating systems, compilers for embedded controllers, scientific computing, and performance‐critical libraries. Interpreters are valuable for rapid development, scripting, automation, server‐side scripting on web servers, education and interactive development tools. Many modern systems combine compilation and interpretation techniques (bytecode, virtual machines, JIT) to balance portability and performance.

Keywords and concepts to remember

• Source code
• Machine code
• Compiler
• Interpreter
• Compilation phases (preprocessing, lexical, syntax, semantic, optimisation, code generation, linking)
• Bytecode, JVM, JIT
• Executable