Openai·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

Apr 2026Remote

Summary

OpenAI coding round where they had me build a working interpreter from scratch for a toy language. Starts simple but they keep adding requirements, so the initial design really matters.

Questions Asked (1)

Build an interpreter for a small toy programming language that supports variable assignment, arithmetic, and print output, with the expectation that follow-up rounds will add features like conditionals, loops, and functions.

Algorithms & Data StructuresTechnical Trade-offsSystem Design

Author's notes

The part that tripped me up wasn't parsing, it was scope.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the language's syntax and semantics, then design a modular interpreter with separate lexer, parser, and evaluator components. Emphasize extensibility for future features like conditionals and loops, and discuss trade-offs between tree-walking and bytecode approaches.

Pro tip: Mention that you'll use an AST-based tree-walking interpreter for simplicity and extensibility, and that you'll structure the environment to support nested scopes for future functions. This shows foresight and practical design sense.

1. Clarify Requirements and Scope

Ask questions to pin down syntax, supported operations, error handling, and performance expectations. Confirm that the core is a REPL or script runner and that extensibility is key.

2. Design the Architecture

Outline a classic interpreter pipeline: lexer -> parser -> AST -> evaluator. Explain how each component will be modular to allow adding new features without major rewrites.

3. Define the Grammar and AST

Sketch a simple grammar for assignments, arithmetic expressions, and print statements. Define AST node types (e.g., Assign, BinaryOp, Print) that can be extended later.

4. Implement the Evaluator

Describe a tree-walking evaluator that maintains an environment (symbol table) for variables. Discuss handling of arithmetic operations and print output.

5. Plan for Extensibility

Explain how you would add conditionals, loops, and functions in follow-up rounds. For example, introduce control flow nodes, block scoping, and function objects with closures.

Key Points to Mention

Lexer/Parser separation and use of recursive descent parsing for simplicity.
AST design with visitor pattern or polymorphic evaluation for extensibility.
Environment/symbol table with support for nested scopes (important for functions).
Error handling: parse errors, runtime errors (e.g., undefined variable, division by zero).
Trade-offs: tree-walking vs. bytecode compilation; simplicity vs. performance.
Testing strategy: unit tests for each component and integration tests for end-to-end scenarios.

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