Openai·Software Engineer·Onsite - Coding / Algorithms·Senior

Senior

Apr 2026

Summary

OpenAI SWE interview, 75-minute coding round centered on building a toy language interpreter from scratch. The live extension twist mid-round is real and not just a rumor, so be ready for the goalposts to move.

Questions Asked (1)

Implement a small interpreter for a toy programming language: tokenize source input, parse statements (assignments, arithmetic expressions, print/output), evaluate them, and handle any language extensions the interviewer adds mid-round.

Algorithms & Data StructuresTechnical Trade-offsAdaptability & Ambiguity

Author's notes

This is the whole round, not just one question.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the language's grammar and semantics, then implement a clean pipeline: tokenizer, parser (e.g., recursive descent), and evaluator with an environment for variables. Keep the design modular and extensible so you can quickly add features like new operators or control flow when the interviewer asks.

Pro tip: Before coding, write down a few example programs and their expected outputs to validate your implementation and catch edge cases early. Also, mention that you'll use a symbol table (environment) to handle variable scoping and assignments.

1. Clarify requirements and grammar

Ask the interviewer about the exact syntax and semantics: what operators, data types, and statements are needed? Confirm whether variables are dynamically typed and how print works.

2. Design the architecture

Outline the components: tokenizer, parser (AST), evaluator, and environment. Choose a parsing strategy (e.g., recursive descent) and decide on error handling.

3. Implement tokenizer and parser

Write a tokenizer that converts source into tokens, then a parser that builds an AST. Start with assignments, arithmetic, and print, ensuring correct operator precedence.

4. Implement evaluator

Traverse the AST to evaluate expressions and execute statements, using an environment to store variable values. Handle errors like undefined variables.

5. Extend and test

When the interviewer adds features (e.g., if statements, loops), extend the tokenizer, parser, and evaluator accordingly. Test with sample programs and edge cases.

Key Points to Mention

Tokenization: use regular expressions or manual scanning to produce tokens (numbers, identifiers, operators, keywords).
Parsing: recursive descent for expressions with precedence (e.g., factor, term, expression) and statements.
Evaluation: environment (symbol table) for variable storage; evaluate expressions recursively.
Error handling: report syntax errors with line numbers and runtime errors like division by zero or undefined variables.
Extensibility: design AST nodes and evaluator methods to easily add new features (e.g., visitor pattern or polymorphic eval).
Testing: write unit tests for tokenizer, parser, and evaluator; use example programs to verify correctness.

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