configuration/lexicon/data/metaprogramming.data.json
configuration/lexicon/data/metaprogramming.data.json is a file in GovLab Context. 195 lines of code and 0 definitions.
{
"category": "metaprogramming-language-oriented-architecture",
"records": [
{
"name": "Code-as-Data Representation",
"kind": "constraint",
"definition": "The requirement that a program's code be representable in the same data structures the language manipulates."
},
{
"name": "Macro Systems",
"kind": "mechanism",
"definition": "A facility that lets code transform other code at compile time by operating on its data representation."
},
{
"name": "Opaque Syntax Trees",
"kind": "anti-pattern",
"definition": "Syntax trees a program cannot inspect or manipulate as data, so code cannot be transformed programmatically."
},
{
"name": "AST or Data Representation",
"kind": "constraint",
"definition": "The requirement that code be represented as a structured syntax tree or data rather than as raw text."
},
{
"name": "Program Transformation",
"kind": "capability",
"definition": "The ability to analyze and rewrite a program by manipulating its structured representation."
},
{
"name": "Safety/Debuggability",
"kind": "quality-attribute",
"definition": "The degree to which treating code as manipulable data can obscure what runs and make it harder to debug."
},
{
"name": "String-Based Code Generation",
"kind": "anti-pattern",
"definition": "Building code by concatenating strings, so the result is unchecked, injection-prone, and hard to analyze."
},
{
"name": "Boilerplate Elimination",
"kind": "capability",
"definition": "The ability to remove repetitive boilerplate by generating it from a single declaration."
},
{
"name": "Explicit Handwritten Code",
"kind": "approach",
"definition": "Writing code out by hand explicitly rather than generating it, favoring directness and debuggability over reuse."
},
{
"name": "Reflection/AST/Code Generation",
"kind": "constraint",
"definition": "The requirement that a language expose reflection, syntax trees, or code generation for programs to manipulate themselves."
},
{
"name": "Performance/Safety",
"kind": "quality-attribute",
"definition": "The degree to which inspecting and dispatching on types at runtime costs performance and bypasses static safety."
},
{
"name": "Runtime Type Metadata",
"kind": "artifact",
"definition": "Type information retained at runtime so a program can inspect the shape of its own values."
},
{
"name": "Diagnostics",
"kind": "capability",
"definition": "The ability to inspect a running system's own structure and state to diagnose it."
},
{
"name": "Self-Describing Systems",
"kind": "quality-attribute",
"definition": "The degree to which a system carries enough metadata to describe its own structure and capabilities at runtime."
},
{
"name": "Build Complexity",
"kind": "quality-attribute",
"definition": "The degree to which moving work into the build to run at compile time makes the build harder to set up and reason about."
},
{
"name": "Compile-Time Inputs",
"kind": "constraint",
"definition": "The requirement that the inputs a computation needs be known at compile time so it can run then."
},
{
"name": "Early Error Detection",
"kind": "capability",
"definition": "The ability to catch errors at compile time rather than letting them surface at runtime."
},
{
"name": "Runtime Dynamic Evaluation",
"kind": "technique",
"definition": "Evaluating code or expressions dynamically at runtime, trading compile-time checking for runtime flexibility."
},
{
"name": "Dynamic Optimization/Adaptation",
"kind": "capability",
"definition": "The ability to generate specialized code at runtime to optimize or adapt to observed conditions."
},
{
"name": "Safe Generation Boundary",
"kind": "constraint",
"definition": "The requirement that runtime code generation be confined to a safe, sandboxed boundary away from untrusted input."
},
{
"name": "Security/Debugging",
"kind": "quality-attribute",
"definition": "The degree to which generating and running code at runtime widens the attack surface and complicates debugging."
},
{
"name": "Domain Expressiveness",
"kind": "capability",
"definition": "The ability to express domain rules directly in terms a domain expert recognizes."
},
{
"name": "Formal Grammar/Semantics",
"kind": "constraint",
"definition": "The requirement that a domain language have a defined grammar and semantics rather than an ad-hoc syntax."
},
{
"name": "General-Purpose Boilerplate",
"kind": "anti-pattern",
"definition": "Expressing domain logic through verbose general-purpose code and its boilerplate instead of a concise domain notation."
},
{
"name": "Tooling/Maintenance",
"kind": "quality-attribute",
"definition": "The degree to which owning a custom language burdens a team with building and maintaining its tooling."
},
{
"name": "Code Generation or Interpreters",
"kind": "constraint",
"definition": "The requirement that a domain language be backed by a generator or interpreter that executes it."
},
{
"name": "Domain Modeling",
"kind": "activity",
"definition": "Expressing a problem domain as a first-class language of its own concepts and rules."
},
{
"name": "High-Level Domain Expression",
"kind": "capability",
"definition": "The ability to express solutions in high-level domain terms rather than low-level general-purpose code."
},
{
"name": "One-Size General-Purpose Code",
"kind": "approach",
"definition": "Expressing every domain in a single general-purpose language, rather than in domain-specific notations."
},
{
"name": "Toolchain Complexity",
"kind": "quality-attribute",
"definition": "The degree to which building custom languages adds compilers, parsers, and editors to a project's toolchain."
},
{
"name": "Formal Model",
"kind": "model",
"definition": "A precise, machine-processable model of a system from which implementations are generated."
},
{
"name": "Generated Implementations",
"kind": "artifact",
"definition": "Implementation code produced automatically from a model rather than written by hand."
},
{
"name": "Handwritten Divergence",
"kind": "anti-pattern",
"definition": "Hand-editing generated code so it drifts from the model it came from, breaking regeneration."
},
{
"name": "Transformation Rules",
"kind": "constraint",
"definition": "The requirement that explicit rules define how a model maps to generated implementation code."
},
{
"name": "Syntax Tree Generation",
"kind": "technique",
"definition": "A technique for generating code by building and printing a syntax tree instead of concatenating strings."
},
{
"name": "Reflective Contract Bypass",
"kind": "anti-pattern",
"definition": "A defect in which reflection is used to reach members that a type's contract or visibility hides."
},
{
"name": "Deferred Static Check",
"kind": "anti-pattern",
"definition": "A defect in which a check or generation that could run at compile time is repeated at runtime."
},
{
"name": "Ad-Hoc Mini-Language",
"kind": "anti-pattern",
"definition": "A defect in which rules are written in an informal mini-language that has no grammar and no validator."
}
]
}