Suggest an editImprove this articleRefine the answer for “When is using the Interpreter pattern justified?”. Your changes go to moderation before they’re published.Approval requiredContentWhat you’re changing🇺🇸EN🇺🇦UAPreviewTitle (EN)Short answer (EN)The **Interpreter** pattern is justified when you need to **embed a small language or set of rules into a system**, which can be **described, stored, and interpreted at runtime**, without complex parsers or external DSLs. **Key point:** an interpreter is used where a simple, extensible, "executable" structure of rules or expressions is needed, not a full programming language.Shown above the full answer for quick recall.Answer (EN)ImageThe **Interpreter** pattern is justified when you need to **embed a small language or set of rules into a system**, which can be **described, stored, and interpreted at runtime**, without complex parsers or external DSLs. --- ### 1. **When the Language or Grammar Is Small and Stable** If the set of expressions is limited (for example, simple arithmetic, filters, logical conditions), Interpreter lets you implement support for that language without a bulky parser. > *Example:* an interpreter for math expressions like `a + b * 3`. --- ### 2. **When Users Need the Ability to Define Logic** If the system should let the user **enter rules or formulas**, and the program should **understand and execute them**, Interpreter is ideal. > *Example:* a business rules engine where an administrator writes: > `"if amount > 1000 and customer is VIP, give a 10% discount"`. --- ### 3. **When the Language Is Used Frequently Inside the System** If the application's internal logic is naturally described through expressions or commands (for example, filters, search, scenarios), it's more convenient to express it through your own mini-language than to hardcode it. > *Example:* SQL-like filters in an ORM (`price > 100 AND category = 'Books'`). --- ### 4. **When It's Important to Extend the Language Easily** Each grammar rule is implemented as a separate class, so new constructs can be added **through extension**, without breaking existing code. > *Example:* adding a new `pow()` operation to expressions without changing old classes. --- ### 5. **When Interpretation Happens Often and Compilation Isn't Needed** Interpreter does not compile expressions, it executes them **"on the fly"**, so it fits scenarios where **flexible, dynamic execution** of rules matters. --- ### **When Not to Apply It** - If the language is **large or complex** (better to use a parser/generator, such as ANTLR). - If performance is critical (interpretation is slower than compilation). --- ### **Conclusion** The **Interpreter** pattern is justified when you need to: - implement a **small DSL (embedded language)**; - let users **define logic as expressions**; - **flexibly extend the grammar** without changing existing code. **Summary:** An interpreter is used where a **simple, extensible, "executable" structure of rules or expressions** is needed, not a full programming language.For the reviewerNote to the moderator (optional)Visible only to the moderator. Helps review go faster.