Openai·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

Apr 2026

Summary

OpenAI Research Engineer interview with a meaty systems/languages question. The whole thing was basically one extended coding problem that kept growing, which I wasn't fully ready for.

Questions Asked (1)

Build an interpreter for a small toy programming language supporting variable assignment, basic arithmetic, and print statements. Walk through tokenizing input, parsing into statements or an AST, evaluating with a variable environment, and handling errors like undefined variables or type mismatches.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

I spent too long on the tokenizer and ran out of steam by the time we got to error handling.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the language's scope and requirements, then outline a classic interpreter pipeline: tokenizer, parser, evaluator, and error handling. Walk through each stage with a simple example, emphasizing modular design and robust error reporting.

Pro tip: Demonstrate how you'd structure the code for extensibility, such as using a visitor pattern for the AST or a pluggable error handler, and mention how you'd test each component independently.

1. Clarify Requirements and Scope

Ask about the language's features, error handling expectations, and performance constraints to tailor your design. Confirm the basic operations: assignment, arithmetic, and print.

2. Design the Tokenizer

Define token types (identifiers, numbers, operators, keywords) and implement a lexer that converts input into a token stream, handling whitespace and invalid characters.

3. Design the Parser and AST

Choose a parsing strategy (e.g., recursive descent) and define AST node types for statements and expressions. Parse tokens into an AST, ensuring correct precedence and associativity.

4. Implement the Evaluator

Create an environment (e.g., a map) for variable storage. Traverse the AST to evaluate expressions and execute statements, updating the environment and producing output for print.

5. Handle Errors Gracefully

Detect and report errors like undefined variables, type mismatches, and syntax errors with clear messages and line numbers. Consider error recovery strategies.

Key Points to Mention

Tokenization: using regular expressions or manual scanning to produce tokens with type and value.
Parsing: recursive descent or Pratt parsing for expressions, handling operator precedence.
AST design: node classes for Assignment, BinaryOp, Print, etc., enabling easy traversal.
Environment: a symbol table (e.g., hash map) for variable lookup and assignment.
Error handling: distinguishing between syntax, runtime, and type errors; providing informative messages.
Extensibility: how to add new features (e.g., conditionals, loops) with minimal changes.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.