Compilers & Languages Interview Questions and Answers

A compiler translates the whole program from source into machine code or an intermediate form before it runs, producing an executable. Errors are reported after the whole translation, and the resulting program runs without the compiler present and typically fast, because optimisation happens ahead of time.

An interpreter executes the source directly, reading and evaluating one statement or expression at a time. It starts instantly and gives immediate feedback, which is great for scripting and REPLs, but execution is slower because it re-analyses code as it goes.

compiler:    source -> compiler -> machine code -> run
interpreter: source -> interpreter -> output

The line is blurry. Java compiles to bytecode and a JVM interprets or just-in-time compiles it. JavaScript engines parse to bytecode and optimise hot paths at runtime. Python compiles to bytecode then interprets it. Most modern languages mix both strategies for startup speed plus peak performance.

A typical compiler pipeline has a front end, a middle end and a back end.

• Lexical analysis: turn characters into tokens.
• Syntax analysis: build a parse tree from the token stream using the grammar.
• Semantic analysis: check types, scopes and declarations, and build a symbol table.
• Intermediate representation: lower the tree to a form such as three-address code or SSA.
• Optimisation: improve the IR without changing meaning, for example constant folding and dead code elimination.
• Code generation: emit target machine code or bytecode, including register allocation and instruction selection.

chars -> lexer -> tokens -> parser -> AST -> semantics
      -> IR -> optimiser -> codegen -> machine code

Front ends are language-specific, back ends are target-specific, and the shared IR is what lets a compiler support many languages and many CPUs without an explosion of combinations.

An abstract syntax tree, AST, is a tree representation of a program's structure. The parser produces it after checking that the token stream matches the grammar. It is called abstract because it omits details that do not matter for later processing, such as parentheses and separators.

For the expression 1 + 2 * 3, the AST captures precedence directly, with + at the root and * below it:

      +
     / \
    1   *
       / \
      2   3

Nodes represent constructs such as literals, binary operators, function declarations and statements. ASTs are used by compilers for semantic analysis, optimisation and code generation, and by linters, formatters, transpilers and refactoring tools. The concrete parse tree usually keeps more detail and is closer to the grammar, while the AST is the practical working form. Traversal is commonly done with the visitor pattern.