LISP Interview Questions

LISP interviews, whether for a Common Lisp, Scheme, Clojure, or Emacs Lisp role, tend to probe a consistent set of fundamentals: list manipulation with car/cdr/cons, the difference between quoting and evaluation, recursion versus iteration, closures, and macros versus functions. Interviewers use these topics not just to test rote syntax knowledge but to see whether a candidate genuinely understands LISP's core model of code and data both being built from the same list structures.

A near-universal opener is explaining car and cdr: given a list (1 2 3), car returns the first element (1) and cdr returns the rest of the list ((2 3)), and cons builds a new pair by prepending an element, so (cons 1 '(2 3)) reconstructs (1 2 3). Interviewers also probe quoting: 'x (or (quote x)) prevents evaluation and returns the symbol or list literally, whereas without the quote, LISP would try to evaluate x as a variable reference or, if it's a list, treat its first element as a function call—candidates who confuse (list 1 2) with '(1 2) usually haven't internalized this distinction yet.

Interviewers frequently ask candidates to write a recursive function—reversing a list, computing Fibonacci numbers, or flattening a nested list—both to check correctness and to see if the candidate can identify and construct a tail-recursive version that avoids stack growth. A related staple is explaining closures: a function created inside another function that captures variables from its enclosing lexical scope, such as a counter-generator function that returns a new closure each time it's called, each with its own private captured state, which tests whether the candidate understands lexical scoping as distinct from dynamic scoping.

A frequently asked conceptual question is 'what's the difference between a function and a macro?'—the expected answer is that a function's arguments are evaluated before the function body runs, while a macro receives its arguments as unevaluated code and returns new code to be evaluated in its place, which is why macros can implement control structures like a custom while loop that a function fundamentally cannot. Another common gotcha question involves dynamic versus lexical scope: Common Lisp's special variables (declared with defvar or defparameter) use dynamic scope, where a variable's value is looked up based on the current call stack rather than where the code was textually written, and candidates are expected to explain why this differs from the lexical scoping used by ordinary let-bound variables.