Let's Write a PostScript Interpreter

The author, RebelPotato, explores the philosophy of "human-scale" programming languages by demonstrating how to build a simplified PostScript interpreter in JavaScript. This hands-on journey dissects PostScript's unique stack-based execution model and concatenative programming style, offering insights into language design and interpreter construction.

• PostScript Fundamentals: The article explains PostScript's token-based parsing, its reliance on an operand stack for arguments, and a dictionary stack for name-value associations, exemplified by def and mul operations.
• Data Representation: It details how PostScript data types (numbers, booleans, names, arrays, procedures, operators) are mapped to concise JavaScript data structures, such as Numbers, Strings, Arrays, Maps, and custom objects for procedures.
• Parsing and Tokenization: A JavaScript parse function is introduced, using regular expressions to tokenize PostScript code, handling comments, delimiters, and numbers, and grouping procedure tokens.
• Interpreter Core: The interpreter's architecture is outlined using global JavaScript arrays o (operand stack) and d (dictionary stack), with functions for stack manipulation (push, pop) and exec for sequential token execution.
• Primitive Operators: A collection of JavaScript functions representing PostScript's primitive operators (add, mul, for, ifelse, def) is provided, demonstrating their interaction with the stacks.
• Interactive REPL: The author shows how to integrate the interpreter into a Read-Eval-Print-Loop (REPL) using Node.js or QuickJS for interactive testing, including a format function for output.
• Extending the Interpreter: Readers are encouraged to expand the interpreter by defining new operators in PostScript (e.g., abs, min, fib) or adding more primitive features (e.g., error handling, additional data types).
• Concatenative Programming Insights: The article discusses PostScript's concatenative nature, comparing its stack manipulation (roll, index) to Forth, and notes the implications of its dynamic scoping and limited programmer control over the execution stack.

By offering a practical, human-scale implementation of a classic language, the article empowers readers to not only understand interpreter mechanics but also to gain a deeper appreciation for the elegance and challenges of language design. It serves as an excellent starting point for further experimentation and a satisfying dive into building foundational computing tools.