# The lex records whose category is metaprogramming-language-oriented-architecture

This index as JSON: https://banes-lab.com/json/api/facets/lex/category/metaprogramming-language-oriented-architecture

## Entries

- [Code-as-Data Representation](https://banes-lab.com/records/lex/code-as-data-representation.md): The requirement that a program's code be representable in the same data structures the language manipulates.
- [Macro Systems](https://banes-lab.com/records/lex/macro-systems.md): A facility that lets code transform other code at compile time by operating on its data representation.
- [Opaque Syntax Trees](https://banes-lab.com/records/lex/opaque-syntax-trees.md): Syntax trees a program cannot inspect or manipulate as data, so code cannot be transformed programmatically.
- [AST or Data Representation](https://banes-lab.com/records/lex/ast-or-data-representation.md): The requirement that code be represented as a structured syntax tree or data rather than as raw text.
- [Program Transformation](https://banes-lab.com/records/lex/program-transformation.md): The ability to analyze and rewrite a program by manipulating its structured representation.
- [Safety/Debuggability](https://banes-lab.com/records/lex/safety-debuggability.md): The degree to which treating code as manipulable data can obscure what runs and make it harder to debug.
- [String-Based Code Generation](https://banes-lab.com/records/lex/string-based-code-generation.md): Building code by concatenating strings, so the result is unchecked, injection-prone, and hard to analyze.
- [Boilerplate Elimination](https://banes-lab.com/records/lex/boilerplate-elimination.md): The ability to remove repetitive boilerplate by generating it from a single declaration.
- [Explicit Handwritten Code](https://banes-lab.com/records/lex/explicit-handwritten-code.md): Writing code out by hand explicitly rather than generating it, favoring directness and debuggability over reuse.
- [Reflection/AST/Code Generation](https://banes-lab.com/records/lex/reflection-ast-code-generation.md): The requirement that a language expose reflection, syntax trees, or code generation for programs to manipulate themselves.
- [Performance/Safety](https://banes-lab.com/records/lex/performance-safety.md): The degree to which inspecting and dispatching on types at runtime costs performance and bypasses static safety.
- [Runtime Type Metadata](https://banes-lab.com/records/lex/runtime-type-metadata.md): Type information retained at runtime so a program can inspect the shape of its own values.
- [Diagnostics](https://banes-lab.com/records/lex/diagnostics.md): The ability to inspect a running system's own structure and state to diagnose it.
- [Opaque Runtime](https://banes-lab.com/records/lex/opaque-runtime.md): A runtime that exposes nothing about its own structure, so its components and state cannot be inspected.
- [Self-Describing Systems](https://banes-lab.com/records/lex/self-describing-systems.md): The degree to which a system carries enough metadata to describe its own structure and capabilities at runtime.
- [Build Complexity](https://banes-lab.com/records/lex/build-complexity.md): The degree to which moving work into the build to run at compile time makes the build harder to set up and reason about.
- [Compile-Time Inputs](https://banes-lab.com/records/lex/compile-time-inputs.md): The requirement that the inputs a computation needs be known at compile time so it can run then.
- [Early Error Detection](https://banes-lab.com/records/lex/early-error-detection.md): The ability to catch errors at compile time rather than letting them surface at runtime.
- [Runtime Dynamic Evaluation](https://banes-lab.com/records/lex/runtime-dynamic-evaluation.md): Evaluating code or expressions dynamically at runtime, trading compile-time checking for runtime flexibility.
- [Dynamic Optimization/Adaptation](https://banes-lab.com/records/lex/dynamic-optimization-adaptation.md): The ability to generate specialized code at runtime to optimize or adapt to observed conditions.
- [Safe Generation Boundary](https://banes-lab.com/records/lex/safe-generation-boundary.md): The requirement that runtime code generation be confined to a safe, sandboxed boundary away from untrusted input.
- [Security/Debugging](https://banes-lab.com/records/lex/security-debugging.md): The degree to which generating and running code at runtime widens the attack surface and complicates debugging.
- [Domain Expressiveness](https://banes-lab.com/records/lex/domain-expressiveness.md): The ability to express domain rules directly in terms a domain expert recognizes.
- [Formal Grammar/Semantics](https://banes-lab.com/records/lex/formal-grammar-semantics.md): The requirement that a domain language have a defined grammar and semantics rather than an ad-hoc syntax.
- [General-Purpose Boilerplate](https://banes-lab.com/records/lex/general-purpose-boilerplate.md): Expressing domain logic through verbose general-purpose code and its boilerplate instead of a concise domain notation.
- [Tooling/Maintenance](https://banes-lab.com/records/lex/tooling-maintenance.md): The degree to which owning a custom language burdens a team with building and maintaining its tooling.
- [Code Generation or Interpreters](https://banes-lab.com/records/lex/code-generation-or-interpreters.md): The requirement that a domain language be backed by a generator or interpreter that executes it.
- [Domain Modeling](https://banes-lab.com/records/lex/domain-modeling.md): Expressing a problem domain as a first-class language of its own concepts and rules.
- [High-Level Domain Expression](https://banes-lab.com/records/lex/high-level-domain-expression.md): The ability to express solutions in high-level domain terms rather than low-level general-purpose code.
- [One-Size General-Purpose Code](https://banes-lab.com/records/lex/one-size-general-purpose-code.md): Expressing every domain in a single general-purpose language, rather than in domain-specific notations.
- [Toolchain Complexity](https://banes-lab.com/records/lex/toolchain-complexity.md): The degree to which building custom languages adds compilers, parsers, and editors to a project's toolchain.
- [Formal Model](https://banes-lab.com/records/lex/formal-model.md): A precise, machine-processable model of a system from which implementations are generated.
- [Generated Implementations](https://banes-lab.com/records/lex/generated-implementations.md): Implementation code produced automatically from a model rather than written by hand.
- [Handwritten Divergence](https://banes-lab.com/records/lex/handwritten-divergence.md): Hand-editing generated code so it drifts from the model it came from, breaking regeneration.
- [Transformation Rules](https://banes-lab.com/records/lex/transformation-rules.md): The requirement that explicit rules define how a model maps to generated implementation code.