# Every published address for lexicon terms, part 3 of 5

This leaf as JSON: https://banes-lab.com/json/api/ids/lexicon/_3
count: 474
group: lexicon

| ref | kind | title | summary | json | markdown | bytes | fingerprint |
| --- | --- | --- | --- | --- | --- | --- | --- |
| lexicon:hateoas-style-navigation | capability | HATEOAS-style Navigation | The ability for clients to navigate an API by following links it returns in its responses. | https://banes-lab.com/json/records/lexicon/hateoas-style-navigation | https://banes-lab.com/records/lexicon/hateoas-style-navigation.md | 3940 | e6c3a874aa0d76aa46c08d0bb17489a6d73ed99b146a2d4e8c3439dea7d65234 |
| lexicon:plugin-loading | capability | Plugin Loading | The ability to discover and load plugins declared in manifests at runtime. | https://banes-lab.com/json/records/lexicon/plugin-loading | https://banes-lab.com/records/lexicon/plugin-loading.md | 3367 | 44bc19f4c37fcc825388f3bb3d37206a74df043def52d11f82f3e2c4f23b8264 |
| lexicon:reduced-boilerplate | capability | Reduced Boilerplate | The ability to avoid repetitive boilerplate by relying on conventions. | https://banes-lab.com/json/records/lexicon/reduced-boilerplate | https://banes-lab.com/records/lexicon/reduced-boilerplate.md | 3483 | 001535f7eac7db8a92f1699e9c6ee3d9fd791185dfad466f934dcb8abf221f3a |
| lexicon:runtime-configuration-without-code-change | capability | Runtime Configuration without Code Change | The ability to change a system's behavior by editing configuration rather than code. | https://banes-lab.com/json/records/lexicon/runtime-configuration-without-code-change | https://banes-lab.com/records/lexicon/runtime-configuration-without-code-change.md | 3425 | 4f8534438b4878c4f391240d128341f969f6e83ebf40484b974a0b8792ab7186 |
| lexicon:manifest | artifact | Manifest | A declarative document listing a component's capabilities and metadata. | https://banes-lab.com/json/records/lexicon/manifest | https://banes-lab.com/records/lexicon/manifest.md | 3877 | 219bf788d9b747409f16c793ccfb39afff2ef2e920c9ef83b7916e679756ad28 |
| lexicon:manifest-schema | artifact | Manifest Schema | A formal definition of the structure a manifest must follow. | https://banes-lab.com/json/records/lexicon/manifest-schema | https://banes-lab.com/records/lexicon/manifest-schema.md | 3256 | c09ee279c3d1b48796b0341cedba57a71b46179af2fda95d455818f47210be90 |
| lexicon:metadata-schema | artifact | Metadata Schema | A formal definition of the metadata fields that drive a system's behavior. | https://banes-lab.com/json/records/lexicon/metadata-schema | https://banes-lab.com/records/lexicon/metadata-schema.md | 3325 | f6709a75d916734c46f56f574b2827ecd87e52aa805e724145639bc66e749f8a |
| lexicon:explicit-semantics | constraint | Explicit Semantics | The requirement that declarative configuration carry an explicit, defined meaning. | https://banes-lab.com/json/records/lexicon/explicit-semantics | https://banes-lab.com/records/lexicon/explicit-semantics.md | 3362 | 26a80abf1b155e42fe0dac03636e1e948349dc2ada9d4914f6d84a5a1b8d9aa6 |
| lexicon:stable-conventions | constraint | Stable Conventions | The requirement that the conventions a system relies on stay stable and well-known. | https://banes-lab.com/json/records/lexicon/stable-conventions | https://banes-lab.com/records/lexicon/stable-conventions.md | 3393 | c140d14e78fe5db1657e4d3a9271d6bd46354c3158080324f467a8a2189c2683 |
| lexicon:declaration-drift | quality-attribute | Declaration Drift | The degree to which a declared capability set drifts out of sync with the actual behavior. | https://banes-lab.com/json/records/lexicon/declaration-drift | https://banes-lab.com/records/lexicon/declaration-drift.md | 4205 | 421d022830b60989d7bdfc370909076b85f65f569490113114634be2dc8a6b21 |
| lexicon:dynamic-complexity | quality-attribute | Dynamic Complexity | The degree to which interpreting declarative configuration at runtime adds hidden dynamic complexity. | https://banes-lab.com/json/records/lexicon/dynamic-complexity | https://banes-lab.com/records/lexicon/dynamic-complexity.md | 4220 | 8cf80450275c3a1c10d9f6a657997696129de8b055a5cd4e04e94466d8969b48 |
| lexicon:explicitness | quality-attribute | Explicitness | The degree to which relying on conventions reduces the explicitness of how a system is configured. | https://banes-lab.com/json/records/lexicon/explicitness | https://banes-lab.com/records/lexicon/explicitness.md | 4218 | 83b1fbef73fa9ee576d6f63f42d168b6984da5f8f4649e4811649e51eb7800a9 |
| lexicon:manifest-drift | quality-attribute | Manifest Drift | The degree to which a manifest drifts out of sync with the components it declares. | https://banes-lab.com/json/records/lexicon/manifest-drift | https://banes-lab.com/records/lexicon/manifest-drift.md | 4110 | 1209d7c030541f468bc9f50fe7317d8de16abbad4474fe6cbf645ab019513938 |
| lexicon:metadata-drift | quality-attribute | Metadata Drift | The degree to which self-describing metadata drifts out of sync with the actual system. | https://banes-lab.com/json/records/lexicon/metadata-drift | https://banes-lab.com/records/lexicon/metadata-drift.md | 4210 | b1cc6b715e65071052304b8d215179c2e548dfd42572800bc4fbcd2c56a1a27c |
| lexicon:payload-verbosity | quality-attribute | Payload Verbosity | The degree to which embedding self-description in responses enlarges their payloads. | https://banes-lab.com/json/records/lexicon/payload-verbosity | https://banes-lab.com/records/lexicon/payload-verbosity.md | 4139 | d65898a577d631ee7d8d28ffc6e61d3910e46bb0bd85c0a9aa66ab513569417e |
| lexicon:self-description | quality-attribute | Self-Description | The degree to which a component exposes its own capabilities and structure for inspection. | https://banes-lab.com/json/records/lexicon/self-description | https://banes-lab.com/records/lexicon/self-description.md | 3341 | d43b5678eb0a3935c6059e0560b1f995b4c480b0590c8028d20c99febad7b00f |
| lexicon:size-overhead | quality-attribute | Size Overhead | The degree to which embedding structural descriptions in data increases its size. | https://banes-lab.com/json/records/lexicon/size-overhead | https://banes-lab.com/records/lexicon/size-overhead.md | 4215 | 432601ab3ce9d9079a18be44082dfbc957f7e759a84aaa3c82abf4ba283db898 |
| lexicon:runtime-topology-report | technique | Runtime Topology Report | A technique for having a system report its loaded components and their bindings at startup. | https://banes-lab.com/json/records/lexicon/runtime-topology-report | https://banes-lab.com/records/lexicon/runtime-topology-report.md | 3214 | c083a619f1413d6cb0fb649221bcea4cf0f1aefe42596ee92e52b0a7066b6c56 |
| lexicon:binding-decision-log | technique | Binding Decision Log | A technique for logging which implementation was bound to each extension point and why. | https://banes-lab.com/json/records/lexicon/binding-decision-log | https://banes-lab.com/records/lexicon/binding-decision-log.md | 3238 | 8deacb327cb05689c6b91ef98d0667af7172f9b1bc0d0cc18a302ffaa5b161a0 |
| lexicon:declare-capability | technique | Declare Capability | A technique for having each component state in metadata what it provides and what it requires. | https://banes-lab.com/json/records/lexicon/declare-capability | https://banes-lab.com/records/lexicon/declare-capability.md | 7566 | 3067977bdbb24cf2e8839c9b79a3fc9fb6cc49dbcb203aaea88e6f5f2f3dd075 |
| lexicon:unvalidated-metadata | anti-pattern | Unvalidated Metadata | A defect in which metadata that drives behavior is read without being validated against a schema. | https://banes-lab.com/json/records/lexicon/unvalidated-metadata | https://banes-lab.com/records/lexicon/unvalidated-metadata.md | 3429 | 7ff9bc7390247aa483a7dcb9f39bdb23f74a72e1264f32c7b284fdad8e0e7f2a |
| lexicon:code-as-data-representation | constraint | Code-as-Data Representation | The requirement that a program's code be representable in the same data structures the language manipulates. | https://banes-lab.com/json/records/lexicon/code-as-data-representation | https://banes-lab.com/records/lexicon/code-as-data-representation.md | 3370 | 34c2e60629a0a1944d5292e10fc51183d79cfcb4390d7d3507581fbc26ed95ad |
| lexicon:macro-systems | mechanism | Macro Systems | A facility that lets code transform other code at compile time by operating on its data representation. | https://banes-lab.com/json/records/lexicon/macro-systems | https://banes-lab.com/records/lexicon/macro-systems.md | 3372 | de2f998443c1c309030ed03583b06c797ce6ec1d63c234f9c1393b9ca20602e2 |
| lexicon:opaque-syntax-trees | anti-pattern | Opaque Syntax Trees | Syntax trees a program cannot inspect or manipulate as data, so code cannot be transformed programmatically. | https://banes-lab.com/json/records/lexicon/opaque-syntax-trees | https://banes-lab.com/records/lexicon/opaque-syntax-trees.md | 3369 | 8c7e8a8914c4721bb91c8d7ce8126cc2a4519e2d5956fc7d19944dc99b458116 |
| lexicon:ast-or-data-representation | constraint | AST or Data Representation | The requirement that code be represented as a structured syntax tree or data rather than as raw text. | https://banes-lab.com/json/records/lexicon/ast-or-data-representation | https://banes-lab.com/records/lexicon/ast-or-data-representation.md | 3394 | af719b38849365d8c316e375ac0e0348fa193ecdcfe2fd6a702092869f95dd06 |
| lexicon:program-transformation | capability | Program Transformation | The ability to analyze and rewrite a program by manipulating its structured representation. | https://banes-lab.com/json/records/lexicon/program-transformation | https://banes-lab.com/records/lexicon/program-transformation.md | 3392 | afcaeba01335919467d5e563c02fe38469a69642d1d31040bc497a06cf12513f |
| lexicon:safety-debuggability | quality-attribute | Safety/Debuggability | The degree to which treating code as manipulable data can obscure what runs and make it harder to debug. | https://banes-lab.com/json/records/lexicon/safety-debuggability | https://banes-lab.com/records/lexicon/safety-debuggability.md | 4222 | 0ecdf601bf21a8c1454c4a4589c29dc2adeaa58012e12ed82cf14d345618002a |
| lexicon:string-based-code-generation | anti-pattern | String-Based Code Generation | Building code by concatenating strings, so the result is unchecked, injection-prone, and hard to analyze. | https://banes-lab.com/json/records/lexicon/string-based-code-generation | https://banes-lab.com/records/lexicon/string-based-code-generation.md | 3834 | 5fb117f62ce7b2753c72e5ce2b4b661c9161fcc48bf09bb9e399ac4b4d7b8b6c |
| lexicon:boilerplate-elimination | capability | Boilerplate Elimination | The ability to remove repetitive boilerplate by generating it from a single declaration. | https://banes-lab.com/json/records/lexicon/boilerplate-elimination | https://banes-lab.com/records/lexicon/boilerplate-elimination.md | 3443 | 6c4817230dcacbc25a9493fd2900c17907416239d4444441a3b7d461d629ad2f |
| lexicon:explicit-handwritten-code | approach | Explicit Handwritten Code | Writing code out by hand explicitly rather than generating it, favoring directness and debuggability over reuse. | https://banes-lab.com/json/records/lexicon/explicit-handwritten-code | https://banes-lab.com/records/lexicon/explicit-handwritten-code.md | 4311 | fbc202b2017ac4cb4ab06f44f033300682758ff9e3b9431e75d3b6ecf8c88925 |
| lexicon:reflection-ast-code-generation | constraint | Reflection/AST/Code Generation | The requirement that a language expose reflection, syntax trees, or code generation for programs to manipulate themselves. | https://banes-lab.com/json/records/lexicon/reflection-ast-code-generation | https://banes-lab.com/records/lexicon/reflection-ast-code-generation.md | 3456 | 4b3b411a630a3a700c449bb3040ff1f7f46969b1ca52b8e6d058d4c2264b3a51 |
| lexicon:performance-safety | quality-attribute | Performance/Safety | The degree to which inspecting and dispatching on types at runtime costs performance and bypasses static safety. | https://banes-lab.com/json/records/lexicon/performance-safety | https://banes-lab.com/records/lexicon/performance-safety.md | 4197 | b90a066ca8d9de791b90c6a62d2c4119ac737916d48d7a5c37b5141eabe5b918 |
| lexicon:runtime-type-metadata | artifact | Runtime Type Metadata | Type information retained at runtime so a program can inspect the shape of its own values. | https://banes-lab.com/json/records/lexicon/runtime-type-metadata | https://banes-lab.com/records/lexicon/runtime-type-metadata.md | 3291 | 716a4aaa8d6adc36fd026466820a8073aa5451e237f4c6378eade25840940271 |
| lexicon:diagnostics | capability | Diagnostics | The ability to inspect a running system's own structure and state to diagnose it. | https://banes-lab.com/json/records/lexicon/diagnostics | https://banes-lab.com/records/lexicon/diagnostics.md | 3761 | 8b31272f32151f25b59dcf2fe331f6f81c10f171600000b255af8cfea4a15603 |
| lexicon:self-describing-systems | quality-attribute | Self-Describing Systems | The degree to which a system carries enough metadata to describe its own structure and capabilities at runtime. | https://banes-lab.com/json/records/lexicon/self-describing-systems | https://banes-lab.com/records/lexicon/self-describing-systems.md | 3336 | 76facab7b391100a91faee5b9bb6837d9fe2bac74259691168e2b56838a9f783 |
| lexicon:build-complexity | quality-attribute | Build Complexity | The degree to which moving work into the build to run at compile time makes the build harder to set up and reason about. | https://banes-lab.com/json/records/lexicon/build-complexity | https://banes-lab.com/records/lexicon/build-complexity.md | 4272 | eec3c83f572aa8c9aa56c270eeb5b9b51d8b6545e2f9bba383d49444d9004cfe |
| lexicon:compile-time-inputs | constraint | Compile-Time Inputs | The requirement that the inputs a computation needs be known at compile time so it can run then. | https://banes-lab.com/json/records/lexicon/compile-time-inputs | https://banes-lab.com/records/lexicon/compile-time-inputs.md | 3396 | 9f29eec9fb45297936593da1327b483f79095eb9b5c184351f642304a9c2d268 |
| lexicon:early-error-detection | capability | Early Error Detection | The ability to catch errors at compile time rather than letting them surface at runtime. | https://banes-lab.com/json/records/lexicon/early-error-detection | https://banes-lab.com/records/lexicon/early-error-detection.md | 3435 | f8a7c336c09d8b5be300e83cdc3d2475a6af39ebabcd5ab0287cb1434ad249a8 |
| lexicon:runtime-dynamic-evaluation | technique | Runtime Dynamic Evaluation | Evaluating code or expressions dynamically at runtime, trading compile-time checking for runtime flexibility. | https://banes-lab.com/json/records/lexicon/runtime-dynamic-evaluation | https://banes-lab.com/records/lexicon/runtime-dynamic-evaluation.md | 4393 | 09f70601e5f5b78f5fd95f4fccd27de26a104475adcf5820d40ccb0296db757c |
| lexicon:dynamic-optimization-adaptation | capability | Dynamic Optimization/Adaptation | The ability to generate specialized code at runtime to optimize or adapt to observed conditions. | https://banes-lab.com/json/records/lexicon/dynamic-optimization-adaptation | https://banes-lab.com/records/lexicon/dynamic-optimization-adaptation.md | 3508 | 2e2a068b6692352561cadb453ffe6324b9ea8737a2f606088c1d0fff1ed20056 |
| lexicon:safe-generation-boundary | constraint | Safe Generation Boundary | The requirement that runtime code generation be confined to a safe, sandboxed boundary away from untrusted input. | https://banes-lab.com/json/records/lexicon/safe-generation-boundary | https://banes-lab.com/records/lexicon/safe-generation-boundary.md | 3493 | b24e87166b46dbf7996c9f0b401062aaf6e0b6062bfa9e5f43179755cbfb229b |
| lexicon:security-debugging | quality-attribute | Security/Debugging | The degree to which generating and running code at runtime widens the attack surface and complicates debugging. | https://banes-lab.com/json/records/lexicon/security-debugging | https://banes-lab.com/records/lexicon/security-debugging.md | 4739 | 47b5fcbdfb7bc8e67dd941e4deca7245d0e5d6bce601350bb7e84b4f576086d2 |
| lexicon:domain-expressiveness | capability | Domain Expressiveness | The ability to express domain rules directly in terms a domain expert recognizes. | https://banes-lab.com/json/records/lexicon/domain-expressiveness | https://banes-lab.com/records/lexicon/domain-expressiveness.md | 3418 | 5fd52f322afb405e05b22ae4f4bab67ffa76d6c23858e52cd2f67889cfffe300 |
| lexicon:formal-grammar-semantics | constraint | Formal Grammar/Semantics | The requirement that a domain language have a defined grammar and semantics rather than an ad-hoc syntax. | https://banes-lab.com/json/records/lexicon/formal-grammar-semantics | https://banes-lab.com/records/lexicon/formal-grammar-semantics.md | 3485 | 0a942a45f3af237a3d89365175759e8f51ba792ce891ac75b79c27fbde379d57 |
| lexicon:general-purpose-boilerplate | anti-pattern | General-Purpose Boilerplate | Expressing domain logic through verbose general-purpose code and its boilerplate instead of a concise domain notation. | https://banes-lab.com/json/records/lexicon/general-purpose-boilerplate | https://banes-lab.com/records/lexicon/general-purpose-boilerplate.md | 3486 | 5efff2d3b09e886625734667e06281f02489c3b2c6dce998d7b7130a326deab7 |
| lexicon:tooling-maintenance | quality-attribute | Tooling/Maintenance | The degree to which owning a custom language burdens a team with building and maintaining its tooling. | https://banes-lab.com/json/records/lexicon/tooling-maintenance | https://banes-lab.com/records/lexicon/tooling-maintenance.md | 4393 | a19c2cf01f8a089c2665e94f1020e88e6b3396da9dee0908a51d4425c164e30d |
| lexicon:code-generation-or-interpreters | constraint | Code Generation or Interpreters | The requirement that a domain language be backed by a generator or interpreter that executes it. | https://banes-lab.com/json/records/lexicon/code-generation-or-interpreters | https://banes-lab.com/records/lexicon/code-generation-or-interpreters.md | 3459 | d3340ef58d9f3e7c0995dedc69fd0ac782d0b0a15e5650de92e4b17cd67177bc |
| lexicon:domain-modeling | activity | Domain Modeling | Expressing a problem domain as a first-class language of its own concepts and rules. | https://banes-lab.com/json/records/lexicon/domain-modeling | https://banes-lab.com/records/lexicon/domain-modeling.md | 3938 | 4d43331387d6d0cefdf4d9c600205b38278482147bf2db386bbaeb95de2b55be |
| lexicon:high-level-domain-expression | capability | High-Level Domain Expression | The ability to express solutions in high-level domain terms rather than low-level general-purpose code. | https://banes-lab.com/json/records/lexicon/high-level-domain-expression | https://banes-lab.com/records/lexicon/high-level-domain-expression.md | 3503 | e608fa405ca5b55adaba146f0b8057565f2e93df8e8da6056c7c44d30bfd2a94 |
| lexicon:one-size-general-purpose-code | approach | One-Size General-Purpose Code | Expressing every domain in a single general-purpose language, rather than in domain-specific notations. | https://banes-lab.com/json/records/lexicon/one-size-general-purpose-code | https://banes-lab.com/records/lexicon/one-size-general-purpose-code.md | 4453 | c45d844af92f74726a282f7e9877a528a70ad8129a9db88aa410cd260c2288b0 |
| lexicon:toolchain-complexity | quality-attribute | Toolchain Complexity | The degree to which building custom languages adds compilers, parsers, and editors to a project's toolchain. | https://banes-lab.com/json/records/lexicon/toolchain-complexity | https://banes-lab.com/records/lexicon/toolchain-complexity.md | 4351 | 38fd41c8925a08711c3b73846ec62a41b3350b5f4a2199d831ace8011692afc5 |
| lexicon:formal-model | model | Formal Model | A precise, machine-processable model of a system from which implementations are generated. | https://banes-lab.com/json/records/lexicon/formal-model | https://banes-lab.com/records/lexicon/formal-model.md | 4402 | ddc95252e7eebb37d8cce8b29b5f0b8c07121205cd5dc5c74b824567ddb4eef0 |
| lexicon:generated-implementations | artifact | Generated Implementations | Implementation code produced automatically from a model rather than written by hand. | https://banes-lab.com/json/records/lexicon/generated-implementations | https://banes-lab.com/records/lexicon/generated-implementations.md | 3400 | 0a16c3d691be90893ef67efd3dbcc2476600275c063c3703c8af586bcc367eea |
| lexicon:handwritten-divergence | anti-pattern | Handwritten Divergence | Hand-editing generated code so it drifts from the model it came from, breaking regeneration. | https://banes-lab.com/json/records/lexicon/handwritten-divergence | https://banes-lab.com/records/lexicon/handwritten-divergence.md | 3932 | 27a6293073630e73c1169ec992024e8b040fa0fa7e95eb3bff538d0923b3509f |
| lexicon:transformation-rules | constraint | Transformation Rules | The requirement that explicit rules define how a model maps to generated implementation code. | https://banes-lab.com/json/records/lexicon/transformation-rules | https://banes-lab.com/records/lexicon/transformation-rules.md | 3442 | 4e9613cf85a3d3e03f3b689603dfa2538fe6694ec0ac503e3890375a05585091 |
| lexicon:syntax-tree-generation | technique | Syntax Tree Generation | A technique for generating code by building and printing a syntax tree instead of concatenating strings. | https://banes-lab.com/json/records/lexicon/syntax-tree-generation | https://banes-lab.com/records/lexicon/syntax-tree-generation.md | 4153 | 98ecd246577528f705a152e4ef71e4d9712f278a5d0a503c6a606d192293fdde |
| lexicon:reflective-contract-bypass | anti-pattern | Reflective Contract Bypass | A defect in which reflection is used to reach members that a type's contract or visibility hides. | https://banes-lab.com/json/records/lexicon/reflective-contract-bypass | https://banes-lab.com/records/lexicon/reflective-contract-bypass.md | 3389 | 1506bb3430f1cd36848fca78dab13686e2af478b48a067ef2da474858e75588a |
| lexicon:deferred-static-check | anti-pattern | Deferred Static Check | A defect in which a check or generation that could run at compile time is repeated at runtime. | https://banes-lab.com/json/records/lexicon/deferred-static-check | https://banes-lab.com/records/lexicon/deferred-static-check.md | 3446 | 054c5a0a53fcd431a8cd5d7a6e8f24c29e42bb8c21125df69e99c9f29978f18f |
| lexicon:ad-hoc-mini-language | anti-pattern | Ad-Hoc Mini-Language | A defect in which rules are written in an informal mini-language that has no grammar and no validator. | https://banes-lab.com/json/records/lexicon/ad-hoc-mini-language | https://banes-lab.com/records/lexicon/ad-hoc-mini-language.md | 3905 | 6bc78c4e25b3974939fa2c88720e602b0b7fa40702f4431716d6ce3baf40028f |
| lexicon:ad-hoc-notebook-to-production | anti-pattern | Ad-Hoc Notebook-to-Production | Promoting exploratory notebook code straight to production without engineering it into a reliable pipeline. | https://banes-lab.com/json/records/lexicon/ad-hoc-notebook-to-production | https://banes-lab.com/records/lexicon/ad-hoc-notebook-to-production.md | 3229 | a97dc3654d5b2f9cbbe64c6a467c2d51171359202e7e7b7b1feea462685b7c19 |
| lexicon:deploy-and-forget-models | anti-pattern | Deploy-and-Forget Models | Deploying a model and never monitoring it, so degradation as the data drifts goes unnoticed. | https://banes-lab.com/json/records/lexicon/deploy-and-forget-models | https://banes-lab.com/records/lexicon/deploy-and-forget-models.md | 3671 | a3bfea05033d9e5700794f6df7acae2e31b1a9ae9afb0c039a5f99ad744774ae |
| lexicon:exact-keyword-search-only | anti-pattern | Exact Keyword Search Only | Relying solely on exact keyword matching for retrieval, missing semantically related results. | https://banes-lab.com/json/records/lexicon/exact-keyword-search-only | https://banes-lab.com/records/lexicon/exact-keyword-search-only.md | 3576 | 5da45272c8da869d3527b89b1d846d0eb63e7d7f774a45f51fecb66118efad67 |
| lexicon:flat-document-only-knowledge | anti-pattern | Flat Document-Only Knowledge | Representing knowledge as unlinked flat documents, losing the relationships a graph would capture. | https://banes-lab.com/json/records/lexicon/flat-document-only-knowledge | https://banes-lab.com/records/lexicon/flat-document-only-knowledge.md | 3618 | 3206c28db42104937db553e7efc5d1b13f202c22158ac21193d6e9d83f640631 |
| lexicon:opaque-black-box-decisions | anti-pattern | Opaque Black-Box Decisions | Producing model decisions with no explanation, so their reasoning cannot be inspected or trusted. | https://banes-lab.com/json/records/lexicon/opaque-black-box-decisions | https://banes-lab.com/records/lexicon/opaque-black-box-decisions.md | 3609 | f751a0f0b2b80a2a4f167ca060e281330143135c46a40f3b085078ee76129c98 |
| lexicon:opaque-ungoverned-model-use | anti-pattern | Opaque Ungoverned Model Use | Using models with no governance or oversight, leaving their behavior and risks unmanaged. | https://banes-lab.com/json/records/lexicon/opaque-ungoverned-model-use | https://banes-lab.com/records/lexicon/opaque-ungoverned-model-use.md | 4190 | cedb5f361820ee992084973194a9c15b4a9caa9999ce04ad69d654d2c61060d0 |
| lexicon:training-time-only-model-logic | anti-pattern | Training-Time-Only Model Logic | Building logic that exists only during training, with no counterpart to serve predictions at inference. | https://banes-lab.com/json/records/lexicon/training-time-only-model-logic | https://banes-lab.com/records/lexicon/training-time-only-model-logic.md | 3209 | edc3eeaf6a7e551ba31a21f3445d270ba22db34e2998055bb3fdae502e24f886 |
| lexicon:unapproved-model-deployment | anti-pattern | Unapproved Model Deployment | Deploying a model to production without passing the required review and approval gates. | https://banes-lab.com/json/records/lexicon/unapproved-model-deployment | https://banes-lab.com/records/lexicon/unapproved-model-deployment.md | 3603 | 573ed637e7e199517477a094127c84a33d38aa90e4fc8f35d3bd0d7959cd896b |
| lexicon:ungrounded-generation | anti-pattern | Ungrounded Generation | Generating output from a model alone without grounding it in retrieved facts, inviting hallucination. | https://banes-lab.com/json/records/lexicon/ungrounded-generation | https://banes-lab.com/records/lexicon/ungrounded-generation.md | 3733 | 668e5a2f1cc44a5ae0976c38114390d747c24da38dbe1927c5f27cffa2cec512 |
| lexicon:unguarded-model-autonomy | anti-pattern | Unguarded Model Autonomy | Letting a model act autonomously with no safety guardrails on what it can do. | https://banes-lab.com/json/records/lexicon/unguarded-model-autonomy | https://banes-lab.com/records/lexicon/unguarded-model-autonomy.md | 3516 | ab74419ca711032a423d16e514a1492110624e76f4523b198bcd499a273629c5 |
| lexicon:untested-model-deployment | anti-pattern | Untested Model Deployment | Deploying a model without evaluating it, so its real-world quality is unknown until it fails. | https://banes-lab.com/json/records/lexicon/untested-model-deployment | https://banes-lab.com/records/lexicon/untested-model-deployment.md | 3541 | fa3e294e9341cd7f2d79ede334dcab9d971e4a5c5bbef21374b99050a6457741 |
| lexicon:approval-policy | constraint | Approval Policy | The declared rules and gates a model must pass before it may be deployed. | https://banes-lab.com/json/records/lexicon/approval-policy | https://banes-lab.com/records/lexicon/approval-policy.md | 3048 | e51f019725a1b9d36ccde8f11131976dfeea1d4ddcdd619f00f2167e0e358d65 |
| lexicon:document-store | artifact | Document Store | The body of documents a retrieval system searches to ground a model's generation. | https://banes-lab.com/json/records/lexicon/document-store | https://banes-lab.com/records/lexicon/document-store.md | 3065 | 478de605c2274acfa8d0840745b2e5e8b4cb19cdd3c8995be1faeb8d531f7151 |
| lexicon:data-pipeline | mechanism | Data Pipeline | The stages that ingest, clean, and transform data into a form suitable for training or inference. | https://banes-lab.com/json/records/lexicon/data-pipeline | https://banes-lab.com/records/lexicon/data-pipeline.md | 3606 | 726dc7751c402ac4de773f8ecebb0cd1031931c0036ae2d3a24d0bd5c24b3fe4 |
| lexicon:data-model-boundaries | constraint | Data/Model Boundaries | The lines separating data preparation, model training, and serving so each concern stays isolated. | https://banes-lab.com/json/records/lexicon/data-model-boundaries | https://banes-lab.com/records/lexicon/data-model-boundaries.md | 3102 | 8db3c47ae988118e3a2c3d69f6c922bcad2e8489bb26116ecaefdd5aa98f18b5 |
| lexicon:dataset | artifact | Dataset | A curated collection of examples used to train or evaluate a model. | https://banes-lab.com/json/records/lexicon/dataset | https://banes-lab.com/records/lexicon/dataset.md | 2968 | ea6c90b0b234132c7ab7276d4fb50f9a53df4785865350051e301ee1fc1b1db0 |
| lexicon:embeddings | artifact | Embeddings | Numeric vector representations of data that place semantically similar items near each other. | https://banes-lab.com/json/records/lexicon/embeddings | https://banes-lab.com/records/lexicon/embeddings.md | 2911 | 5f28dfb3602ad1a3886a184afc3328253349edaddd826265b61a34a6c38c87a6 |
| lexicon:entities | artifact | Entities | The distinct things, such as people, places or concepts, that a knowledge graph represents as nodes. | https://banes-lab.com/json/records/lexicon/entities | https://banes-lab.com/records/lexicon/entities.md | 2990 | f1ef00e135aa0b9de0e24e76ca4d8ebaf323c9fe528a700ed60edee222fe1421 |
| lexicon:grounding-strategy | approach | Grounding Strategy | A scheme for anchoring a model's output in retrieved, authoritative sources rather than its parameters alone. | https://banes-lab.com/json/records/lexicon/grounding-strategy | https://banes-lab.com/records/lexicon/grounding-strategy.md | 3059 | ab9c0bb9dce993ddd68ead10bc7bbd68e4c353f2c1a88eee81d842ab0b7c08cb |
| lexicon:guardrails | mechanism | Guardrails | Constraints and filters that bound what a model is permitted to output or do at runtime. | https://banes-lab.com/json/records/lexicon/guardrails | https://banes-lab.com/records/lexicon/guardrails.md | 6982 | a22cf1fa06844b54b161b6421462223932024e8170928c0b9db8d49dd41f6033 |
| lexicon:input-output-contract | constraint | Input/Output Contract | The agreed schema of the inputs a model accepts and the outputs it returns. | https://banes-lab.com/json/records/lexicon/input-output-contract | https://banes-lab.com/records/lexicon/input-output-contract.md | 2994 | c80ad3301317d37960219dae7ca4f27cbdf81544812a0471c11d6e1856f44dfa |
| lexicon:model-artifact | artifact | Model Artifact | The trained model file, with its learned weights, that is loaded to serve predictions. | https://banes-lab.com/json/records/lexicon/model-artifact | https://banes-lab.com/records/lexicon/model-artifact.md | 3030 | f6341c24bb5588a0a936465f4a02ccd26914ef419ffd9d02eccc772b0e4ef2a1 |
| lexicon:model-registry | artifact | Model Registry | A catalog that tracks model versions, their metadata, and their deployment status. | https://banes-lab.com/json/records/lexicon/model-registry | https://banes-lab.com/records/lexicon/model-registry.md | 3912 | bffb1a30bc2079427bcc403e27027d0a97cf2162e9758ffee0d13937efb7b6bc |
| lexicon:rationale-evidence | artifact | Rationale/Evidence | The reasons and supporting evidence recorded for a model's decision. | https://banes-lab.com/json/records/lexicon/rationale-evidence | https://banes-lab.com/records/lexicon/rationale-evidence.md | 2963 | 1592cd198b3d7df1d9fb94afbf84754d046c11c77334d716d4f07aa550e029bd |
| lexicon:relations | artifact | Relations | The typed connections between entities that a knowledge graph represents as edges. | https://banes-lab.com/json/records/lexicon/relations | https://banes-lab.com/records/lexicon/relations.md | 3414 | c9b1384454247fda880d697c7f20cc2665902e9ad99e463ac82450bbde6c0182 |
| lexicon:retriever | mechanism | Retriever | A component that finds and returns the most relevant documents for a query. | https://banes-lab.com/json/records/lexicon/retriever | https://banes-lab.com/records/lexicon/retriever.md | 3523 | b492fa117b8d59232e816256dc41a37da2b52eda630d6b5574ee5280b7f3bf8d |
| lexicon:schema-ontology | artifact | Schema/Ontology | A formal definition of the entity types and relationship types a knowledge graph may contain. | https://banes-lab.com/json/records/lexicon/schema-ontology | https://banes-lab.com/records/lexicon/schema-ontology.md | 3429 | f6916b115f9901b8e04dc7c0c9b51b2e61d77bbb6839c3bedab1d5eddee57ca4 |
| lexicon:tool-interface | constraint | Tool Interface | The defined contract through which an agent invokes external tools and receives their results. | https://banes-lab.com/json/records/lexicon/tool-interface | https://banes-lab.com/records/lexicon/tool-interface.md | 3110 | c5d76c4cd5ea313f5deee9324df590d198bc01b172faffff14e42d32e1ff1fe9 |
| lexicon:training-inference-separation | constraint | Training/Inference Separation | The requirement that model training and prediction serving be distinct, separately-managed phases. | https://banes-lab.com/json/records/lexicon/training-inference-separation | https://banes-lab.com/records/lexicon/training-inference-separation.md | 3129 | e63b506df3869d83636a9e559da4a5c284e546c123264aa4e8ab9dfbaef57e93 |
| lexicon:vector-index | artifact | Vector Index | A data structure that organizes embedding vectors for fast nearest-neighbor lookup. | https://banes-lab.com/json/records/lexicon/vector-index | https://banes-lab.com/records/lexicon/vector-index.md | 3517 | 53cafea8ff3f13e55eece068af2a6f98d481ad81d0cbb86aec2bfe97230dcade |
| lexicon:retraining-triggers | mechanism | Retraining Triggers | Signals that automatically initiate model retraining when measured drift crosses a threshold. | https://banes-lab.com/json/records/lexicon/retraining-triggers | https://banes-lab.com/records/lexicon/retraining-triggers.md | 3097 | 071cd510c1d649c9bd9c34d7bd2694d1aa7137ca3926c9970458532c9af347ac |
| lexicon:model-integrated-systems | capability | Model-Integrated Systems | The ability of a software system to incorporate models as integral parts of its behavior. | https://banes-lab.com/json/records/lexicon/model-integrated-systems | https://banes-lab.com/records/lexicon/model-integrated-systems.md | 3194 | bc45f1f6461f68d81e5b7cb2fb6b70d2029dd1db41c71be4161cb51c67d78b18 |
| lexicon:audit-and-debugging | capability | Audit and Debugging | The ability to inspect and trace a model's decisions for auditing and debugging. | https://banes-lab.com/json/records/lexicon/audit-and-debugging | https://banes-lab.com/records/lexicon/audit-and-debugging.md | 3110 | f09937cb3d8a7062cad95e647c60060f1850668a352ef3f33e892ca26ad3dcc3 |
| lexicon:bounded-tool-using-agents | capability | Bounded Tool-Using Agents | The ability to run agents that use external tools within defined, safe limits. | https://banes-lab.com/json/records/lexicon/bounded-tool-using-agents | https://banes-lab.com/records/lexicon/bounded-tool-using-agents.md | 3117 | 9711f1bd7db10a54a148ec5a98e99f55e200dd4251e4a581587181356cd242cd |
| lexicon:contextual-generation | capability | Contextual Generation | The ability to generate output informed by retrieved, task-specific context. | https://banes-lab.com/json/records/lexicon/contextual-generation | https://banes-lab.com/records/lexicon/contextual-generation.md | 3209 | 2cf16a5e864414cfe9bc2fd3e2a7d2620bc746002279737b001370d08faf7e91 |
| lexicon:controlled-model-deployment | capability | Controlled Model Deployment | The ability to release models through a governed, approved process. | https://banes-lab.com/json/records/lexicon/controlled-model-deployment | https://banes-lab.com/records/lexicon/controlled-model-deployment.md | 3104 | 6303e9b44cd4dd66cca4670d58cc068a2ddf12a41a640466c8a3890285ba491a |
| lexicon:degradation-detection | capability | Degradation Detection | The ability to detect when a model's accuracy declines as data shifts. | https://banes-lab.com/json/records/lexicon/degradation-detection | https://banes-lab.com/records/lexicon/degradation-detection.md | 3123 | aed4a67e3b3cfb846578cdfb7164c6f44d111f2de7cc60617b0c83ef8e0c069a |
| lexicon:governed-autonomy | capability | Governed Autonomy | The ability to let an agent act autonomously within enforced governance limits. | https://banes-lab.com/json/records/lexicon/governed-autonomy | https://banes-lab.com/records/lexicon/governed-autonomy.md | 3614 | 649561cb47c5dddee8e2652cbf0ca1147867bc427bd586ea658ec1620588027a |
| lexicon:model-selection-regression-detection | capability | Model Selection/Regression Detection | The ability to compare models and catch quality regressions before deployment. | https://banes-lab.com/json/records/lexicon/model-selection-regression-detection | https://banes-lab.com/records/lexicon/model-selection-regression-detection.md | 3216 | 62cb0b7f99aa6b712ff5f9e6babe1839f63e679deb9e5523230e2888576f11e4 |
| lexicon:relationship-aware-retrieval-reasoning | capability | Relationship-Aware Retrieval/Reasoning | The ability to retrieve and reason over the relationships between entities, not just isolated facts. | https://banes-lab.com/json/records/lexicon/relationship-aware-retrieval-reasoning | https://banes-lab.com/records/lexicon/relationship-aware-retrieval-reasoning.md | 3271 | 580f246fa76cf3030fe9ffa02e2e69712824be4e875fa9a8869b5d9543849985 |
| lexicon:reliable-model-lifecycle | capability | Reliable Model Lifecycle | The ability to manage a model's data, training, deployment and monitoring reliably and repeatably. | https://banes-lab.com/json/records/lexicon/reliable-model-lifecycle | https://banes-lab.com/records/lexicon/reliable-model-lifecycle.md | 3273 | 378d88d2a9d3580459e236c712c6d145c582f3034ca8d67e12bb522a01d3d6f6 |
| lexicon:safe-model-deployment | capability | Safe Model Deployment | The ability to deploy models with safeguards that bound their behavior. | https://banes-lab.com/json/records/lexicon/safe-model-deployment | https://banes-lab.com/records/lexicon/safe-model-deployment.md | 3049 | c49c3cb11f9ce8f456b7839d89eaf0681f9560f61b767eb4fbffbe009cb235e6 |
| lexicon:semantic-search | capability | Semantic Search | The ability to find results by meaning and similarity rather than exact keyword match. | https://banes-lab.com/json/records/lexicon/semantic-search | https://banes-lab.com/records/lexicon/semantic-search.md | 3058 | b104c37fe518b00e09d45780ccb8d39dd4f7856a1f022a06a0c321f88ca515e3 |
| lexicon:similarity-retrieval | capability | Similarity Retrieval | The ability to retrieve items nearest to a query in an embedding space. | https://banes-lab.com/json/records/lexicon/similarity-retrieval | https://banes-lab.com/records/lexicon/similarity-retrieval.md | 3071 | f1a7d44ecd77a060d97e0f4a328fb1108d18430066321238be57f14cde53691b |
| lexicon:structured-versioned-prompts | artifact | Structured, Versioned Prompts | Prompts authored as structured, version-controlled artifacts rather than ad-hoc strings. | https://banes-lab.com/json/records/lexicon/structured-versioned-prompts | https://banes-lab.com/records/lexicon/structured-versioned-prompts.md | 3123 | eee7bcaab52517c51f708ee94ae9f18a11a21461b097e6c1914cffcd8477f023 |
| lexicon:knowledge-freshness | quality-attribute | Knowledge Freshness | The degree to which a system's knowledge reflects current rather than stale information. | https://banes-lab.com/json/records/lexicon/knowledge-freshness | https://banes-lab.com/records/lexicon/knowledge-freshness.md | 3129 | d7c49451797882fab084955f2881eb8d1f479e96d81a6706072800882c9ca180 |
| lexicon:trust | quality-attribute | Trust | The degree to which users are willing to rely on a system's outputs. | https://banes-lab.com/json/records/lexicon/trust | https://banes-lab.com/records/lexicon/trust.md | 2992 | e88facd834b32da661febefdebbc1f0ce8deb213ce38e4d9dfcae38678416c86 |
| lexicon:capability-utility | quality-attribute | Capability/Utility | The degree of usefulness a model offers, which strict safety limits can constrain. | https://banes-lab.com/json/records/lexicon/capability-utility | https://banes-lab.com/records/lexicon/capability-utility.md | 3738 | 86e989c45471e4dba95f307b5fbd9b84a94df3ff3618558a5bcd3a25f7ffcfba |
| lexicon:curation-cost | quality-attribute | Curation Cost | The degree of ongoing effort required to build and maintain a curated knowledge graph. | https://banes-lab.com/json/records/lexicon/curation-cost | https://banes-lab.com/records/lexicon/curation-cost.md | 3832 | ee9f4a3779ac7076d271115658444160dacdd21aae7651fb77c792ece88b21b7 |
| lexicon:experiment-velocity | metric | Experiment Velocity | The rate at which model experiments can be run and iterated, which governance can slow. | https://banes-lab.com/json/records/lexicon/experiment-velocity | https://banes-lab.com/records/lexicon/experiment-velocity.md | 3861 | 5c798233cba62266bf0591e348b81df9c3993fd2058a77f6b79925b8ab9d576a |
| lexicon:experimentation-speed | metric | Experimentation Speed | The rate at which new modeling ideas can be tried and evaluated. | https://banes-lab.com/json/records/lexicon/experimentation-speed | https://banes-lab.com/records/lexicon/experimentation-speed.md | 4016 | a6184b37e161023f4dc378f41476eca9465d1c689494c58e7ae330c67d7eb9cd |
| lexicon:explainability-recall | quality-attribute | Explainability/Recall | The degree to which retrieval stays explainable and complete, traded against pure similarity ranking. | https://banes-lab.com/json/records/lexicon/explainability-recall | https://banes-lab.com/records/lexicon/explainability-recall.md | 3869 | cf154de6491ea16d045fa33427e17cf60f21ffc95c3826f00286bbd0520e0c98 |
| lexicon:latency-cost | quality-attribute | Latency/Cost | The degree of latency and expense incurred to serve model predictions. | https://banes-lab.com/json/records/lexicon/latency-cost | https://banes-lab.com/records/lexicon/latency-cost.md | 3812 | b16513215fec36fe67e993965fe67e7c818b81f92a2739b9cceb5a99bc74ffa9 |
| lexicon:metric-completeness | quality-attribute | Metric Completeness | The degree to which evaluation metrics capture every dimension of a model's quality. | https://banes-lab.com/json/records/lexicon/metric-completeness | https://banes-lab.com/records/lexicon/metric-completeness.md | 3839 | 8f4fdfafe71c45c0a7598ebf27a2f79df5c46a61b232ede344ebbccb3d420b58 |
| lexicon:model-complexity | quality-attribute | Model Complexity | The degree of intricacy in a model, which raises accuracy but lowers explainability. | https://banes-lab.com/json/records/lexicon/model-complexity | https://banes-lab.com/records/lexicon/model-complexity.md | 3822 | 67399db17c51dcef9ec82f430380f807c7fd26d44b035e9446d946861104a42d |
| lexicon:monitoring-cost | quality-attribute | Monitoring Cost | The degree of ongoing expense of continuously monitoring a deployed model. | https://banes-lab.com/json/records/lexicon/monitoring-cost | https://banes-lab.com/records/lexicon/monitoring-cost.md | 3918 | ee13cda77ce6780df85e2c3c4bae6415e596b4494d5fba0eec2ee428f11258a0 |
| lexicon:retrieval-quality-latency | quality-attribute | Retrieval Quality/Latency | The degree to which retrieval must trade result quality against speed. | https://banes-lab.com/json/records/lexicon/retrieval-quality-latency | https://banes-lab.com/records/lexicon/retrieval-quality-latency.md | 4051 | 7735b52773ccb25a369eca9f7b5420a95122ab5997f045df38a397725972ad4e |
| lexicon:prompt-registry | technique | Prompt Registry | A technique for keeping prompts in one versioned registry instead of as literals across the code. | https://banes-lab.com/json/records/lexicon/prompt-registry | https://banes-lab.com/records/lexicon/prompt-registry.md | 3872 | ed84c2fc2e3dd79853246af031a4fd4fd157efa36d17c6010cc767a3478b65bd |
| lexicon:prompt-versioning | technique | Prompt Versioning | A technique for giving each prompt, dataset and index a version that inference logs record. | https://banes-lab.com/json/records/lexicon/prompt-versioning | https://banes-lab.com/records/lexicon/prompt-versioning.md | 4274 | 09e0c0c2a7109d8a15191b75896bb36113bda3a89dca684b03adcfe44389181b |
| lexicon:evaluation-suite | technique | Evaluation Suite | A technique for scoring model output against a fixed set of cases on every change to the model, prompt or data. | https://banes-lab.com/json/records/lexicon/evaluation-suite | https://banes-lab.com/records/lexicon/evaluation-suite.md | 5435 | df6926e1224338cb061bfcbe1f3e53e8cca145d8a78eef19392e02f18744d983 |
| lexicon:centralized-model-configuration | technique | Centralized Model Configuration | A technique for holding model names, parameters and limits in one configuration read by every call site. | https://banes-lab.com/json/records/lexicon/centralized-model-configuration | https://banes-lab.com/records/lexicon/centralized-model-configuration.md | 3105 | 1135f3403eeed1fe2f19f942bf677cb7fce3a2492a5143b6b08df1a9bab52203 |
| lexicon:inference-context-record | technique | Inference Context Record | A technique for logging with each model output the model version, prompt version and inputs that produced it. | https://banes-lab.com/json/records/lexicon/inference-context-record | https://banes-lab.com/records/lexicon/inference-context-record.md | 3172 | 5b4d2dd8b62a080748621939d76a1fa7ac9cde7f481433ae215d4c88bd60ddc4 |
| lexicon:evidence-citation | technique | Evidence Citation | A technique for attaching to each generated claim the retrieved source that supports it. | https://banes-lab.com/json/records/lexicon/evidence-citation | https://banes-lab.com/records/lexicon/evidence-citation.md | 5195 | d12d5401ff85305037408ce05c690af658ecd8d6f6eb3696f110e836c2c1d067 |
| lexicon:claim-validation | technique | Claim Validation | A technique for checking generated claims against their cited sources before they are returned. | https://banes-lab.com/json/records/lexicon/claim-validation | https://banes-lab.com/records/lexicon/claim-validation.md | 3101 | 980a8f0b61720880f52d2b401ae7cd266e63c0c3ea5cebcd3ab29014913221a0 |
| lexicon:abstain-or-disclose-uncertainty | technique | Abstain or Disclose Uncertainty | A technique for having a model decline or state its uncertainty when the evidence does not support an answer. | https://banes-lab.com/json/records/lexicon/abstain-or-disclose-uncertainty | https://banes-lab.com/records/lexicon/abstain-or-disclose-uncertainty.md | 3085 | 866191dc0e26952decdf8fcbfb614fb2fd47e71cfd3ec733b4362076a8558235 |
| lexicon:governance-log | technique | Governance Log | A technique for recording each approval, deployment and retirement of a model with who decided it. | https://banes-lab.com/json/records/lexicon/governance-log | https://banes-lab.com/records/lexicon/governance-log.md | 3086 | 3b3a7e0597ee123e9815f3459426777968ef0030d3a1453e6ded99163a82f28e |
| lexicon:cost-noise | quality-attribute | Cost/Noise | The degree to which collecting more telemetry adds cost and noise that can obscure the signals that matter. | https://banes-lab.com/json/records/lexicon/cost-noise | https://banes-lab.com/records/lexicon/cost-noise.md | 3974 | d60b1fbd52095f1006a0a4c2d8fe2d770f23f621e27ad2c702dae049b1c555cf |
| lexicon:incident-diagnosis | capability | Incident Diagnosis | The ability to diagnose the cause of an incident from a system's observable signals. | https://banes-lab.com/json/records/lexicon/incident-diagnosis | https://banes-lab.com/records/lexicon/incident-diagnosis.md | 3133 | 496983376d3da87d2bb1577ad51a32cdaf3d6a1459da1883315462ed5c2b5c22 |
| lexicon:logs | artifact | Logs | A record of discrete, timestamped events a system emits about what it did. | https://banes-lab.com/json/records/lexicon/logs | https://banes-lab.com/records/lexicon/logs.md | 3116 | 91b282eba2602e1b10d72c9606f23ceee022cc2381143b6f2eafd353e857b471 |
| lexicon:traces | artifact | Traces | A record of the path and timing of a request as it moves through a system's components. | https://banes-lab.com/json/records/lexicon/traces | https://banes-lab.com/records/lexicon/traces.md | 3674 | 6b6dc7ea36dfd38d6a48a6ff165a96fec97cdc8dac3d7a646c2545d77a354cd6 |
| lexicon:incident-analysis | capability | Incident Analysis | The ability to reconstruct and analyze an incident from the events a system logged. | https://banes-lab.com/json/records/lexicon/incident-analysis | https://banes-lab.com/records/lexicon/incident-analysis.md | 3193 | c921b0fd0de03585e90521bb7ce66f39b5a71babc492fdce07e3224b885660e5 |
| lexicon:noise-personal-data-leakage | quality-attribute | Noise/Personal Data Leakage | The degree to which verbose logging adds noise and risks leaking personal or sensitive data. | https://banes-lab.com/json/records/lexicon/noise-personal-data-leakage | https://banes-lab.com/records/lexicon/noise-personal-data-leakage.md | 4062 | ae4a0f8fa3a9abb29a1f15df4a15fd64d37b3ae6cf566bec053141ead12d83a1 |
| lexicon:structured-events | artifact | Structured Events | Log entries emitted as structured, machine-parsable records rather than free-form text. | https://banes-lab.com/json/records/lexicon/structured-events | https://banes-lab.com/records/lexicon/structured-events.md | 3649 | b9e560c830c0fbe79145412d655b80956894f792028361b089c18d5a2d08c8d6 |
| lexicon:alert-noise | quality-attribute | Alert Noise | The degree to which monitoring many signals generates alerts that drown out the meaningful ones. | https://banes-lab.com/json/records/lexicon/alert-noise | https://banes-lab.com/records/lexicon/alert-noise.md | 3942 | 7c51a794364d823b29c3597244e02b338dcfe563f68bc894cc1c445cfffb4b8e |
| lexicon:blind-operation | anti-pattern | Blind Operation | Running a system in production with no monitoring, so problems are noticed only when users report them. | https://banes-lab.com/json/records/lexicon/blind-operation | https://banes-lab.com/records/lexicon/blind-operation.md | 3949 | 3b9ff2a43923a44f9aabd9f282e54621f5bd540aa953072a04942f61b10db651 |
| lexicon:failure-detection | capability | Failure Detection | The ability to detect that a system has failed or degraded by watching its monitored signals. | https://banes-lab.com/json/records/lexicon/failure-detection | https://banes-lab.com/records/lexicon/failure-detection.md | 3193 | 898e179efa500b22c26bd8294066174d3003b2b197afdb6f6c35a5adb57a5374 |
| lexicon:alert-fatigue | quality-attribute | Alert Fatigue | The degree to which too many alerts desensitize responders, so the ones that matter are ignored. | https://banes-lab.com/json/records/lexicon/alert-fatigue | https://banes-lab.com/records/lexicon/alert-fatigue.md | 3950 | 14da7fa7010d9cbb1e37bca4ea0357825cb1601e34bcaecc1f91f80479ae1891 |
| lexicon:incident-response | activity | Incident Response | Detecting, triaging, and resolving an operational incident once an alert fires. | https://banes-lab.com/json/records/lexicon/incident-response | https://banes-lab.com/records/lexicon/incident-response.md | 3190 | 011d8634eb6d302f7666f6ad77ae280f0025d341f01ac41ce99c923455b9970b |
| lexicon:timely-intervention | capability | Timely Intervention | The ability to intervene on a problem quickly by being alerted the moment it arises. | https://banes-lab.com/json/records/lexicon/timely-intervention | https://banes-lab.com/records/lexicon/timely-intervention.md | 3197 | 40d5681a8aaeab062996ead9ce451da9df173b5a59641ea1ed7c70f3c35cd4c6 |
| lexicon:accountability | capability | Accountability | The ability to attribute every consequential action to the actor responsible for it. | https://banes-lab.com/json/records/lexicon/accountability | https://banes-lab.com/records/lexicon/accountability.md | 3212 | 8ad03dab808b932f686e3220bb8a3e5b7474f65f9a5baf8fba8dbbf1453f7d16 |
| lexicon:opaque-mutation | anti-pattern | Opaque Mutation | Changing state with no record of who changed what or when, so the change cannot be audited. | https://banes-lab.com/json/records/lexicon/opaque-mutation | https://banes-lab.com/records/lexicon/opaque-mutation.md | 3617 | 83dadca059e014a0eddf6a8398856cd4ce880dc9946ef49bc40fb8f503454936 |
| lexicon:storage-privacy | quality-attribute | Storage/Privacy | The degree to which retaining a full audit history grows storage and raises privacy concerns. | https://banes-lab.com/json/records/lexicon/storage-privacy | https://banes-lab.com/records/lexicon/storage-privacy.md | 3940 | 98d3cf66045bedac3326662fb61d10da586bc6d1201b33f89533f9e33f08bd2d |
| lexicon:action | artifact | Action | A field of an audit record identifying the operation that was performed. | https://banes-lab.com/json/records/lexicon/action | https://banes-lab.com/records/lexicon/action.md | 3654 | b65dee6a9ac28619cbaa4aeddfb9b6f622929e7c92efd41dd5e144ab363c6e4f |
| lexicon:actor | artifact | Actor | A field of an audit record identifying who or what performed an action. | https://banes-lab.com/json/records/lexicon/actor | https://banes-lab.com/records/lexicon/actor.md | 3072 | 3dd723f5e6114cbe53b620a1b4bc974ac9e81afc496adbc01203eee2b28f1c9c |
| lexicon:forensics | capability | Forensics | The ability to reconstruct after the fact what happened from an immutable audit record. | https://banes-lab.com/json/records/lexicon/forensics | https://banes-lab.com/records/lexicon/forensics.md | 3090 | 090d999c7584c939c64e8a1561f73d5c280c8e4b8ef1c4bf51d65d83852c3edc |
| lexicon:privacy | quality-attribute | Privacy | The degree to which a system limits the collection and exposure of personal or sensitive information. | https://banes-lab.com/json/records/lexicon/privacy | https://banes-lab.com/records/lexicon/privacy.md | 3856 | 298d07ace4d76c6d3fd2a4506cdd7896870af1264e91b3c4c25188195378cd4a |
| lexicon:target | artifact | Target | A field of an audit record identifying the resource an action was performed on. | https://banes-lab.com/json/records/lexicon/target | https://banes-lab.com/records/lexicon/target.md | 3641 | 118415d74d5cf7b21b0242079c6f8d0903735f4177e68f0625a3bf8e1aabd941 |
| lexicon:timestamp | artifact | Timestamp | A field of an audit record marking when an action occurred. | https://banes-lab.com/json/records/lexicon/timestamp | https://banes-lab.com/records/lexicon/timestamp.md | 3673 | a803150a519e98e37c1e1ff2f339aad162494930d0a5a753c2edee78cf73ce0b |
| lexicon:untracked-mutation | anti-pattern | Untracked Mutation | Mutating state without writing an audit entry, so the change leaves no trace. | https://banes-lab.com/json/records/lexicon/untracked-mutation | https://banes-lab.com/records/lexicon/untracked-mutation.md | 3585 | 32f7901629cb94704b61d7d7a20e57ee7cd0f210666b6915927bbc0340030a55 |
| lexicon:anonymous-flow | anti-pattern | Anonymous Flow | Data or requests flowing through a system with no identifiers, so their path cannot be reconstructed. | https://banes-lab.com/json/records/lexicon/anonymous-flow | https://banes-lab.com/records/lexicon/anonymous-flow.md | 3251 | 8a85b5701823d4120193f497c3ae94a1867e9907490dfd277b6e812b3d08c374 |
| lexicon:end-to-end-causality | capability | End-to-End Causality | The ability to follow a request's cause-and-effect chain across every component it touches. | https://banes-lab.com/json/records/lexicon/end-to-end-causality | https://banes-lab.com/records/lexicon/end-to-end-causality.md | 3198 | ddc0afafbfdea0be2623333637671a201ea1c3e659bcf0f151d03293217fbb5d |
| lexicon:logs-traces | artifact | Logs/Traces | The combined log and trace records that let a request be followed from end to end. | https://banes-lab.com/json/records/lexicon/logs-traces | https://banes-lab.com/records/lexicon/logs-traces.md | 3272 | 41e617ad3cac0ae1f982a9fcedcc4ba26b3cb8f8a04502b52dcf47825f47253b |
| lexicon:metadata-propagation-overhead | quality-attribute | Metadata Propagation Overhead | The degree to which carrying trace metadata through every call adds size and processing cost. | https://banes-lab.com/json/records/lexicon/metadata-propagation-overhead | https://banes-lab.com/records/lexicon/metadata-propagation-overhead.md | 4111 | 823502c43ea77036c402d7228bdfba6c78cdf35c8a6b737f7d25f945a36880a3 |
| lexicon:context-propagation | constraint | Context Propagation | The requirement that request context be carried across service boundaries so related calls can be correlated. | https://banes-lab.com/json/records/lexicon/context-propagation | https://banes-lab.com/records/lexicon/context-propagation.md | 3373 | 507fb837294ea9495bc12253c649cd1e4ce5517c7036a780e548ff2479e86e81 |
| lexicon:header-metadata-management | quality-attribute | Header/Metadata Management | The degree to which threading correlation identifiers through headers adds handling to every call. | https://banes-lab.com/json/records/lexicon/header-metadata-management | https://banes-lab.com/records/lexicon/header-metadata-management.md | 4184 | 56769c3cfadffa7fb5aa24fc485c467efe27f7e7681e20eb8ee2296096f5817c |
| lexicon:request-level-traceability | capability | Request-Level Traceability | The ability to trace all work belonging to one request by a shared correlation identifier. | https://banes-lab.com/json/records/lexicon/request-level-traceability | https://banes-lab.com/records/lexicon/request-level-traceability.md | 3331 | 32d21eccfc736e4b18892cd97780600b203d795e2e714ca5850e3abcf1145824 |
| lexicon:uncorrelated-events | anti-pattern | Uncorrelated Events | Emitting events with no shared identifier, so those belonging to one request cannot be tied together. | https://banes-lab.com/json/records/lexicon/uncorrelated-events | https://banes-lab.com/records/lexicon/uncorrelated-events.md | 4043 | c0de9461954089effd2c2460942551b0fb6120d4d0f4203f1ac55dcae30da4ab |
| lexicon:audit-trail | artifact | Audit Trail | A chronological record linking each event to the one that caused it. | https://banes-lab.com/json/records/lexicon/audit-trail | https://banes-lab.com/records/lexicon/audit-trail.md | 3245 | 66589899475a82d658f16e099bf91d5c34102d2a302a4569452f4e3c86de933a |
| lexicon:cause-effect-reconstruction | capability | Cause-Effect Reconstruction | The ability to reconstruct which event triggered which by following causation identifiers. | https://banes-lab.com/json/records/lexicon/cause-effect-reconstruction | https://banes-lab.com/records/lexicon/cause-effect-reconstruction.md | 3225 | ec5318039a4b16d1c508f44f6da94a6e74b8c2a90abbe78b0666215217ecd2b4 |
| lexicon:event-metadata | artifact | Event Metadata | Descriptive fields attached to an event, such as its identifiers, timestamps, and causation links. | https://banes-lab.com/json/records/lexicon/event-metadata | https://banes-lab.com/records/lexicon/event-metadata.md | 3280 | eef3e9b704cd8fa0e5e345c6f462b25b52f5d75f16d0241b1a72e04110888cd6 |
| lexicon:metadata-verbosity | quality-attribute | Metadata Verbosity | The degree to which stamping every event with causation metadata makes the event payload verbose. | https://banes-lab.com/json/records/lexicon/metadata-verbosity | https://banes-lab.com/records/lexicon/metadata-verbosity.md | 4011 | 0bcc726fa240ccf61f59e84e341b8c4efa46d5f6784cbf8dfd0b023d8cb5cc20 |
| lexicon:unlinked-events | anti-pattern | Unlinked Events | Recording events with no link to their cause, so cause-and-effect chains cannot be rebuilt. | https://banes-lab.com/json/records/lexicon/unlinked-events | https://banes-lab.com/records/lexicon/unlinked-events.md | 4604 | 4b20e1e6c1d0dc5adde069faaf1a526eb934d692b35aa1e6e9c0a0d935b4fc88 |
| lexicon:latency-failure-root-cause-analysis | capability | Latency/Failure Root Cause Analysis | The ability to pinpoint which service caused a request's latency or failure by tracing it across hops. | https://banes-lab.com/json/records/lexicon/latency-failure-root-cause-analysis | https://banes-lab.com/records/lexicon/latency-failure-root-cause-analysis.md | 3374 | e01ffdd34c4c22b691bb02f5841866d7aa3c06689bdddd5f3eeb9ef0d41af5ee |
| lexicon:opaque-distributed-calls | anti-pattern | Opaque Distributed Calls | Calls crossing service boundaries with no tracing, so a request's path and bottlenecks are invisible. | https://banes-lab.com/json/records/lexicon/opaque-distributed-calls | https://banes-lab.com/records/lexicon/opaque-distributed-calls.md | 3843 | f6db524c43903c149cf590968ee86b5d683aff78bee1131d90014fb63d149e01 |
| lexicon:overhead-sampling | quality-attribute | Overhead/Sampling | The degree to which tracing every request adds overhead, forcing sampling that can miss rare cases. | https://banes-lab.com/json/records/lexicon/overhead-sampling | https://banes-lab.com/records/lexicon/overhead-sampling.md | 4174 | 5b13e92f0d66a1afe408f652ef0e39e2011a85ca5615b00c524f597cd0186e9b |
| lexicon:trace-context-propagation | constraint | Trace Context Propagation | The requirement that trace identifiers be propagated across every hop of a distributed request. | https://banes-lab.com/json/records/lexicon/trace-context-propagation | https://banes-lab.com/records/lexicon/trace-context-propagation.md | 3328 | 1db39a187550377ffcdcc5154392ab4a43955d8cd98941ab7d96e18c1d4d8225 |
| lexicon:error-budget-decisions | capability | Error-Budget Decisions | The ability to decide how much risk to take by spending against a defined reliability error budget. | https://banes-lab.com/json/records/lexicon/error-budget-decisions | https://banes-lab.com/records/lexicon/error-budget-decisions.md | 3269 | c8ce3682aae47a4a95e03e866cdcc2c0e5ec6042b135a99e07c51afc7d93399b |
| lexicon:feature-velocity | quality-attribute | Feature Velocity | The degree to which holding to strict reliability targets limits how fast new features can ship. | https://banes-lab.com/json/records/lexicon/feature-velocity | https://banes-lab.com/records/lexicon/feature-velocity.md | 4022 | ef1fef9407351cb1160a4f53c8e116a747d3a2cb6a27910fcd18b7b9e6782e72 |
| lexicon:vague-reliability-goals | anti-pattern | Vague Reliability Goals | Stating reliability aims in vague, unmeasurable terms, so no check can tell whether they are met. | https://banes-lab.com/json/records/lexicon/vague-reliability-goals | https://banes-lab.com/records/lexicon/vague-reliability-goals.md | 3660 | 284b389e538ecfe340f8a969231d7e3ef46b1c89560da5c03eb786d43e22055e |
| lexicon:at-a-glance-system-health | capability | At-a-Glance System Health | The ability to see a system's overall health at a glance from a consolidated visual display. | https://banes-lab.com/json/records/lexicon/at-a-glance-system-health | https://banes-lab.com/records/lexicon/at-a-glance-system-health.md | 3279 | 1785249874fa9a2933ebe3eacd2acfe3e078afa6a1369e37125b6791a13f6ae3 |
| lexicon:dashboard-sprawl | quality-attribute | Dashboard Sprawl | The degree to which unchecked creation of dashboards scatters attention across too many redundant views. | https://banes-lab.com/json/records/lexicon/dashboard-sprawl | https://banes-lab.com/records/lexicon/dashboard-sprawl.md | 4075 | 55357b6e7fb9f1db8ad2aab8b311254add97bc9faf4f87a187b9ba671dc9d91e |
| lexicon:log-grep-only-diagnosis | anti-pattern | Log-Grep-Only Diagnosis | Diagnosing problems solely by grepping raw logs, with no aggregated view of system health. | https://banes-lab.com/json/records/lexicon/log-grep-only-diagnosis | https://banes-lab.com/records/lexicon/log-grep-only-diagnosis.md | 3638 | 782bc48dcb61aeeb0f8838c9dca764d579087d80291dc534bf11ee8c30602bfb |
| lexicon:trend-visibility | capability | Trend Visibility | The ability to see how a metric is trending over time from a visualized history. | https://banes-lab.com/json/records/lexicon/trend-visibility | https://banes-lab.com/records/lexicon/trend-visibility.md | 3773 | 11af460299c8cf713c44b21e72688bee6dfa1354b4283ffb3457d040d04cbbea |
| lexicon:structured-log | technique | Structured Log | A technique for writing log entries as typed fields, so they are queried by field instead of by text. | https://banes-lab.com/json/records/lexicon/structured-log | https://banes-lab.com/records/lexicon/structured-log.md | 4325 | 634092d726b88355f65c3b89f7171ac81334fdfbab681420b0235eaea5d5b544 |
| lexicon:trace-span | technique | Trace Span | A technique for recording the start, end and context of an operation as a span within a request's trace. | https://banes-lab.com/json/records/lexicon/trace-span | https://banes-lab.com/records/lexicon/trace-span.md | 3145 | e4beda3aaad8b4e78c18b50e7bf713da3a9060fa1d09e864fc101679726c0b7f |
| lexicon:alert-on-critical-failure | technique | Alert on Critical Failure | A technique for raising an alert with an owner and a severity when a critical path fails. | https://banes-lab.com/json/records/lexicon/alert-on-critical-failure | https://banes-lab.com/records/lexicon/alert-on-critical-failure.md | 4417 | b99ce05c63d31924b92c07abe31c2f41fc036d1ed11f3a402210beb42f822f5b |
| lexicon:cardinality-reduction | technique | Cardinality Reduction | A technique for limiting the distinct label values a metric carries, so its storage and queries stay bounded. | https://banes-lab.com/json/records/lexicon/cardinality-reduction | https://banes-lab.com/records/lexicon/cardinality-reduction.md | 3239 | ef582cbc2a82774fa07442dbe49e739edc6c00f40a02d5c395b042cf7cba17b4 |
| lexicon:sampling-and-aggregation | technique | Sampling and Aggregation | A technique for keeping a representative share of telemetry or a summary of it instead of every event. | https://banes-lab.com/json/records/lexicon/sampling-and-aggregation | https://banes-lab.com/records/lexicon/sampling-and-aggregation.md | 3169 | 35cb8f4729155c8719e89de7917d27b10a7acff52a95677e69f85aca71c82793 |
| lexicon:runbook-owner | technique | Runbook Owner | A technique for naming the person or team responsible for each alert and its response steps. | https://banes-lab.com/json/records/lexicon/runbook-owner | https://banes-lab.com/records/lexicon/runbook-owner.md | 3150 | ca01183c2a321e6637c68aed201a9ac6b94469af7bab18408a0af93d8064a563 |
| lexicon:causation-tracing | technique | Causation Tracing | A technique for carrying the id of the event or request that caused each effect, so a chain can be followed back. | https://banes-lab.com/json/records/lexicon/causation-tracing | https://banes-lab.com/records/lexicon/causation-tracing.md | 3157 | 1817d6824705def7c4f07f7dd8b11a41f9341459c169ffd62f7e0e1f9abac2fc |
| lexicon:usage-instrumentation | technique | Usage Instrumentation | A technique for counting calls to a code path in production, so its use is measured before it is removed. | https://banes-lab.com/json/records/lexicon/usage-instrumentation | https://banes-lab.com/records/lexicon/usage-instrumentation.md | 3110 | 982e5e60d48eb061ec66f20ea08322fa90c243f4d8ec3fb6480257ceba8c7e27 |
| lexicon:data-change-audit | technique | Data Change Audit | A technique for recording who changed which data, when, and from what value to what value. | https://banes-lab.com/json/records/lexicon/data-change-audit | https://banes-lab.com/records/lexicon/data-change-audit.md | 5098 | 5a8719c01e86d7163031bd25ebaef4ffa42df3557dc5c18b6c5b956c51fad9c0 |
| lexicon:execution-log | technique | Execution Log | A technique for recording each step an automated or manual procedure performed and its result. | https://banes-lab.com/json/records/lexicon/execution-log | https://banes-lab.com/records/lexicon/execution-log.md | 3167 | 61594ac792ae241c3a0428f50b2e64779ba8bd7a7d75ef5ebf1b6701acc624fe |
| lexicon:define-signal-quality | technique | Define Signal Quality | A technique for stating what makes a log, metric or alert useful before it is emitted. | https://banes-lab.com/json/records/lexicon/define-signal-quality | https://banes-lab.com/records/lexicon/define-signal-quality.md | 3156 | 3aae2cf8d06f8705ec0d030bbb3d29ecf9e619d062935a458862fab779ca2614 |
| lexicon:service-level-objectives | technique | Service Level Objectives | A technique for choosing measured indicators of reliability and setting the targets a service must meet on them. | https://banes-lab.com/json/records/lexicon/service-level-objectives | https://banes-lab.com/records/lexicon/service-level-objectives.md | 4545 | c86752a390932ba656f7495bb195ec7d6ef4a469a767ffc8e638f81544714fb7 |
| lexicon:direct-callback-coupling | anti-pattern | Direct Callback Coupling | Wiring a source to notify specific recipients by direct call, coupling it to each one. | https://banes-lab.com/json/records/lexicon/direct-callback-coupling | https://banes-lab.com/records/lexicon/direct-callback-coupling.md | 3605 | 81f610ddf20915e2e922966563cb59d32175a377b99181b27065d548aa740529 |
| lexicon:direct-method-invocation | anti-pattern | Direct Method Invocation | Invoking an operation by direct method call, so it cannot be queued, logged, or undone. | https://banes-lab.com/json/records/lexicon/direct-method-invocation | https://banes-lab.com/records/lexicon/direct-method-invocation.md | 3571 | 1a3723c2e27623a3bda7d65a867c6b213921198c1ec4f0c1f3f11556858a5d93 |
| lexicon:duplicated-workflow | anti-pattern | Duplicated Workflow | Repeating the same overall algorithm in many places, each copy re-implementing the shared steps. | https://banes-lab.com/json/records/lexicon/duplicated-workflow | https://banes-lab.com/records/lexicon/duplicated-workflow.md | 3700 | 1f9fd91fd62216d5fbfef67a6b9a040db16b6aa26e6db73900ca591ad8442ad5 |
| lexicon:exposed-internal-representation | anti-pattern | Exposed Internal Representation | Forcing clients to traverse a collection through its internal structure, coupling them to that structure. | https://banes-lab.com/json/records/lexicon/exposed-internal-representation | https://banes-lab.com/records/lexicon/exposed-internal-representation.md | 3622 | 6cf00a58dc6df1252aa70f2fda581634a3e55ded87e7ad137a9c8090baa5c8f9 |
| lexicon:external-state-reach-in | anti-pattern | External State Reach-In | Reading or writing an object's internal state from outside to snapshot it, breaking its encapsulation. | https://banes-lab.com/json/records/lexicon/external-state-reach-in | https://banes-lab.com/records/lexicon/external-state-reach-in.md | 3622 | 41e65d0e669d3d72b15d1eabd503e0ded7b7b6bb0974e8abc54b377e60291da6 |
| lexicon:flat-state-explosion | anti-pattern | Flat State Explosion | Enumerating every combination of conditions as a separate flat state, so the state count explodes. | https://banes-lab.com/json/records/lexicon/flat-state-explosion | https://banes-lab.com/records/lexicon/flat-state-explosion.md | 3541 | 469b8faff15392fce6d255a013813d288e945a1a364229dfc2f72ea0cd9c355d |
| lexicon:large-conditional-logic | anti-pattern | Large Conditional Logic | Selecting behavior with a large branching conditional instead of pluggable strategy objects. | https://banes-lab.com/json/records/lexicon/large-conditional-logic | https://banes-lab.com/records/lexicon/large-conditional-logic.md | 3552 | 287d71b12c04c88ee98f161232e26727c27ba5b90cb76cbeb807a1faf4801594 |
| lexicon:mesh-dependencies | anti-pattern | Mesh Dependencies | Letting every object refer directly to every other, forming a dense mesh of point-to-point dependencies. | https://banes-lab.com/json/records/lexicon/mesh-dependencies | https://banes-lab.com/records/lexicon/mesh-dependencies.md | 3560 | 3bbc193681d3937ec2d76823e18228641fd104933ff2e35d8659860c12fba2e1 |
| lexicon:monolithic-handler | anti-pattern | Monolithic Handler | Handling every case in one large handler instead of a chain of focused, single-purpose handlers. | https://banes-lab.com/json/records/lexicon/monolithic-handler | https://banes-lab.com/records/lexicon/monolithic-handler.md | 3731 | 4b01eede2bdd4afb5271e34b53ce08d21a8754cef65221c6861b476847bf828a |
| lexicon:centralized-interaction-logic | capability | Centralized Interaction Logic | The ability to concentrate how a set of objects interact within one mediating component. | https://banes-lab.com/json/records/lexicon/centralized-interaction-logic | https://banes-lab.com/records/lexicon/centralized-interaction-logic.md | 3143 | 68c179ce669b448ca1a2b11cb4d2de13879b04f94137cf0261c63df0b3f62cd7 |
| lexicon:controlled-variation | capability | Controlled Variation | The ability to let subclasses vary only the designated steps of a fixed algorithm. | https://banes-lab.com/json/records/lexicon/controlled-variation | https://banes-lab.com/records/lexicon/controlled-variation.md | 3201 | 395802eb7e126056ba3c3eebb5448b296c35e8832b7fd3ecdfc218437fc99887 |
| lexicon:decoupled-notification | capability | Decoupled Notification | The ability to notify interested parties of a change without the source knowing who they are. | https://banes-lab.com/json/records/lexicon/decoupled-notification | https://banes-lab.com/records/lexicon/decoupled-notification.md | 3120 | 1fa4c8b316425df24365f9a94727e827ed3adffc11f729c1e5eaf7259de8a4f0 |
| lexicon:deferred-execution | capability | Deferred Execution | The ability to capture a request as an object so it can be run later, held in a queue, or logged. | https://banes-lab.com/json/records/lexicon/deferred-execution | https://banes-lab.com/records/lexicon/deferred-execution.md | 3606 | cfdfad633ddf10d4937a49264605b7b7bd23e94a4659f05b4d4a58474bda0210 |
| lexicon:exhaustive-state-reasoning | capability | Exhaustive State Reasoning | The ability to enumerate and reason about every state a system can occupy and every transition between them. | https://banes-lab.com/json/records/lexicon/exhaustive-state-reasoning | https://banes-lab.com/records/lexicon/exhaustive-state-reasoning.md | 3146 | d56745f3092b5b892f67101a03cfd7b4215a1d9e9cc36ffb3cd7f977f1d19a56 |
| lexicon:framework-reuse | capability | Framework Reuse | The ability to reuse a fixed algorithm skeleton across many concrete implementations. | https://banes-lab.com/json/records/lexicon/framework-reuse | https://banes-lab.com/records/lexicon/framework-reuse.md | 3157 | ab016d57a2cefbc95d4a67f4a9d9551bc855c72f28f4942a174821108ffc1b11 |
| lexicon:guarded-transitions | capability | Guarded Transitions | The ability to permit a state transition only when a specified condition holds. | https://banes-lab.com/json/records/lexicon/guarded-transitions | https://banes-lab.com/records/lexicon/guarded-transitions.md | 3497 | 533dcb36084c406b493bd9cba5fcd94314dd35558a01bbc58dc0c6771fd79005 |
| lexicon:hierarchical-states | capability | Hierarchical States | The ability to nest states so shared behavior is defined once on an enclosing state. | https://banes-lab.com/json/records/lexicon/hierarchical-states | https://banes-lab.com/records/lexicon/hierarchical-states.md | 3049 | 4abfa774d7677a20564896ed1171b662a9a952346b61abeb016e97d00f8dfcfd |
| lexicon:lazy-traversal | capability | Lazy Traversal | The ability to produce a collection's elements one at a time on demand rather than all at once. | https://banes-lab.com/json/records/lexicon/lazy-traversal | https://banes-lab.com/records/lexicon/lazy-traversal.md | 3553 | ccf2ebc4ab93c1763fcdf9c93555e52e8624c7480ae7368b63ededa2e8683526 |
| lexicon:null-check-elimination | capability | Null-Check Elimination | The ability to remove scattered null checks by substituting a benign do-nothing object. | https://banes-lab.com/json/records/lexicon/null-check-elimination | https://banes-lab.com/records/lexicon/null-check-elimination.md | 3219 | 5a1783158a4d9cab034761fb2271c569ddf4fc832f651bdc453dda5ecd8ce8e9 |
| lexicon:operation-extension-without-element-change | capability | Operation Extension Without Element Change | The ability to add new operations over a structure without modifying its element classes. | https://banes-lab.com/json/records/lexicon/operation-extension-without-element-change | https://banes-lab.com/records/lexicon/operation-extension-without-element-change.md | 3206 | 5d9e869c1bfadef7d235841abd2799cc3b04104be39a3fdbdd77a992e45b7e3d |
| lexicon:ordered-fallthrough | capability | Ordered Fallthrough | The ability to offer a request to handlers in sequence until one of them accepts it. | https://banes-lab.com/json/records/lexicon/ordered-fallthrough | https://banes-lab.com/records/lexicon/ordered-fallthrough.md | 3722 | 6958452efe72d6fd3bf6a69a7be04374faa49b4cc317e670e1091f660b43c964 |
| lexicon:parallel-regions | capability | Parallel Regions | The ability to model concurrently-active, independent regions of state within one machine. | https://banes-lab.com/json/records/lexicon/parallel-regions | https://banes-lab.com/records/lexicon/parallel-regions.md | 3511 | 7060a9a3eb35056427e2c58a1dcd282bc681f21d31f195994452c12efb814ed1 |
| lexicon:pluggable-handling | capability | Pluggable Handling | The ability to add or reorder request handlers without changing the ones already in the chain. | https://banes-lab.com/json/records/lexicon/pluggable-handling | https://banes-lab.com/records/lexicon/pluggable-handling.md | 3200 | ba9b0c2598b697ca92e2fc5523dc5e6aca06907e8d40ca33718950ece56e7816 |
| lexicon:runtime-behavior-selection | capability | Runtime Behavior Selection | The ability to choose among interchangeable algorithms at runtime. | https://banes-lab.com/json/records/lexicon/runtime-behavior-selection | https://banes-lab.com/records/lexicon/runtime-behavior-selection.md | 3089 | 0172ad84b191b2acf05dd9546773dc22a055b2306335b123cefc76c56814ffeb |
| lexicon:snapshot-restore | capability | Snapshot/Restore | The ability to capture an object's state and later restore it to that captured point. | https://banes-lab.com/json/records/lexicon/snapshot-restore | https://banes-lab.com/records/lexicon/snapshot-restore.md | 3551 | e8433befa3a9881d21619e93d2a36d47321ac47a603d2a4bd0f1411b8420679c |
| lexicon:state-local-behavior | capability | State-Local Behavior | The ability to attach behavior to each state so an object acts according to its current state. | https://banes-lab.com/json/records/lexicon/state-local-behavior | https://banes-lab.com/records/lexicon/state-local-behavior.md | 3128 | 46076a700b8399fac8e24393bfe7a63827e31fabfe1a8519e375591ac59301bd |
| lexicon:structure-agnostic-iteration | capability | Structure-Agnostic Iteration | The ability to traverse a collection without depending on how it is internally organized. | https://banes-lab.com/json/records/lexicon/structure-agnostic-iteration | https://banes-lab.com/records/lexicon/structure-agnostic-iteration.md | 3140 | 9a404610956f0fd63985d1a832e7211f9c5f8358396b0f2da72e19a47702932f |
| lexicon:fail-safe-defaults | principle | Fail-Safe Defaults | Defaulting to safe, benign behavior when a value or handler is absent rather than failing or branching. | https://banes-lab.com/json/records/lexicon/fail-safe-defaults | https://banes-lab.com/records/lexicon/fail-safe-defaults.md | 3181 | 8fd0ee768e0bab25336311d3cae1f81f6694ea59c5522260d292aee5b024b2c8 |
| lexicon:explicit-state-model | constraint | Explicit State Model | The requirement that an object's states and their transitions be modeled explicitly. | https://banes-lab.com/json/records/lexicon/explicit-state-model | https://banes-lab.com/records/lexicon/explicit-state-model.md | 3079 | 9cdf7ea35b72e709cdeccc8be88c0214870f54273528ff38c617d9c8b19cd493 |
| lexicon:explicit-state-set | constraint | Explicit State Set | The requirement that the complete set of possible states be defined up front. | https://banes-lab.com/json/records/lexicon/explicit-state-set | https://banes-lab.com/records/lexicon/explicit-state-set.md | 3149 | 80358a17c43cf44a7158f7f6828000099c632cb1771632c73719c25ad0287cd4 |
| lexicon:interchangeable-algorithms | constraint | Interchangeable Algorithms | The requirement that competing algorithms share one interface so they can be swapped freely. | https://banes-lab.com/json/records/lexicon/interchangeable-algorithms | https://banes-lab.com/records/lexicon/interchangeable-algorithms.md | 3171 | be3c6b3b7d1a378b335a046b8bb556cd1499bd3cc4f78a47838888ca653082ed |
| lexicon:shared-behavioral-interface | constraint | Shared Behavioral Interface | The requirement that the real object and its null stand-in implement one common interface. | https://banes-lab.com/json/records/lexicon/shared-behavioral-interface | https://banes-lab.com/records/lexicon/shared-behavioral-interface.md | 3218 | 23651dabbfe6208fe7b5ef6013abf58e1a31070cc041244dd0bcef83e943066c |
| lexicon:stable-algorithm-skeleton | constraint | Stable Algorithm Skeleton | The requirement that the overall algorithm's structure stay fixed while specific steps vary. | https://banes-lab.com/json/records/lexicon/stable-algorithm-skeleton | https://banes-lab.com/records/lexicon/stable-algorithm-skeleton.md | 3232 | ccfe8ef546828b6ca52dae50fe59d4c138fa2376e9c91142919c3de9ed4d5bce |
| lexicon:stable-element-hierarchy | constraint | Stable Element Hierarchy | The requirement that the set of element types stay fixed so new operations can be added over them. | https://banes-lab.com/json/records/lexicon/stable-element-hierarchy | https://banes-lab.com/records/lexicon/stable-element-hierarchy.md | 3199 | dc6f3b341e7af5c798e3fb8c61ef7e5b59d7227537d16a8ff2868bc4f906ca40 |
| lexicon:subject-subscriber-contract | constraint | Subject/Subscriber Contract | The requirement of an agreed interface by which subjects notify and subscribers receive updates. | https://banes-lab.com/json/records/lexicon/subject-subscriber-contract | https://banes-lab.com/records/lexicon/subject-subscriber-contract.md | 3199 | fd0abf416678fe9affee6bccfb003fa64e91c98e27ab508eaf6056cf9fcf8e36 |
| lexicon:uniform-handler-interface | constraint | Uniform Handler Interface | The requirement that every handler in a chain share one interface so requests pass along uniformly. | https://banes-lab.com/json/records/lexicon/uniform-handler-interface | https://banes-lab.com/records/lexicon/uniform-handler-interface.md | 3294 | fb7c990244f14dc24985ca4d8d1a57b96b139772a3b41e8cd7236d6711a7a52b |
| lexicon:uniform-traversal-interface | constraint | Uniform Traversal Interface | The requirement that collections expose one common interface for stepping through their elements. | https://banes-lab.com/json/records/lexicon/uniform-traversal-interface | https://banes-lab.com/records/lexicon/uniform-traversal-interface.md | 3135 | 7d02a731ec8210c655d9de3f45a51dea2d022629ae80dc84c09a492e75e0532a |
| lexicon:class-count | quality-attribute | Class Count | The degree to which extracting each algorithm into its own class raises the total number of classes. | https://banes-lab.com/json/records/lexicon/class-count | https://banes-lab.com/records/lexicon/class-count.md | 3903 | ab28a35154e34428844eb73ba7498f161c415c2974e480baf578af6a5e8a7707 |
| lexicon:class-proliferation | quality-attribute | Class Proliferation | The degree to which modeling each state as its own class multiplies the number of classes. | https://banes-lab.com/json/records/lexicon/class-proliferation | https://banes-lab.com/records/lexicon/class-proliferation.md | 3875 | 26f7f37d73c2991fa2f549d66320cdea085247d865f9250c3b8d36ce71580c40 |
| lexicon:coordination-complexity | quality-attribute | Coordination Complexity | The degree of complexity in how objects must coordinate, which motivates a mediator. | https://banes-lab.com/json/records/lexicon/coordination-complexity | https://banes-lab.com/records/lexicon/coordination-complexity.md | 3113 | 3d99ca81be79105246109cdeff78e09306037ce99d40a34b8e9ab047634d1ebb |
| lexicon:element-stability | quality-attribute | Element Stability | The degree to which adding new operations stays easy only while the set of element types stays fixed. | https://banes-lab.com/json/records/lexicon/element-stability | https://banes-lab.com/records/lexicon/element-stability.md | 3933 | 8a9e07e8e6baa9ffd31923b7d42715e24f45e39174dede62471246df47dda839 |
| lexicon:inheritance-coupling | quality-attribute | Inheritance Coupling | The degree to which basing a template method on subclassing binds subclasses tightly to the base class. | https://banes-lab.com/json/records/lexicon/inheritance-coupling | https://banes-lab.com/records/lexicon/inheritance-coupling.md | 4007 | c5aba3278ba5f11c308c1a458c8a7907942bff5e56d55d39cc9e0dc174e37f53 |
| lexicon:mediator-god-object | quality-attribute | Mediator God Object | The degree to which concentrating interaction logic in a mediator risks growing it into an overloaded object. | https://banes-lab.com/json/records/lexicon/mediator-god-object | https://banes-lab.com/records/lexicon/mediator-god-object.md | 3934 | 7411e8374eae91ba5e3251affdd5f6a8bc22da86e42c907244254cab35b467db |
| lexicon:memory-footprint | quality-attribute | Memory Footprint | The degree of memory consumed by retaining state snapshots for later restoration. | https://banes-lab.com/json/records/lexicon/memory-footprint | https://banes-lab.com/records/lexicon/memory-footprint.md | 3869 | 84f673f035df5118d7fffc0f634b6364d89760f62cd47175debadc0be74218cd |
| lexicon:silent-no-op-risk | quality-attribute | Silent No-Op Risk | The degree to which a do-nothing stand-in can hide an error. | https://banes-lab.com/json/records/lexicon/silent-no-op-risk | https://banes-lab.com/records/lexicon/silent-no-op-risk.md | 3872 | 5e2d9d22bf8a142e4fcdc4356ddc294c9b90f9db80d4359d56725ae6afcabd4b |
| lexicon:state-explosion | quality-attribute | State Explosion | The degree to which the number of explicit states grows unmanageably as conditions multiply. | https://banes-lab.com/json/records/lexicon/state-explosion | https://banes-lab.com/records/lexicon/state-explosion.md | 3926 | b60d8e5249cf3912998b21eaa993b2a02d1a0929aeb96cd09031e9af855e00f8 |
| lexicon:encode-state-machine | technique | Encode State Machine | A technique for declaring the states and legal transitions of a lifecycle, so an operation called in the wrong state is refused. | https://banes-lab.com/json/records/lexicon/encode-state-machine | https://banes-lab.com/records/lexicon/encode-state-machine.md | 3100 | 2d83658e0b7ff67fa6d9aeb4e3eaf80206acb15181f4746c31067e8286e80aca |
| lexicon:make-order-explicit | technique | Make Order Explicit | A technique for expressing a required call order in types or a state machine instead of in documentation. | https://banes-lab.com/json/records/lexicon/make-order-explicit | https://banes-lab.com/records/lexicon/make-order-explicit.md | 4400 | 1c3a0414261deb68009b36b13e72e9f7320cff4f2254bb5c4a3d784217369ff8 |
| lexicon:scattered-null-guards | anti-pattern | Scattered Null Guards | A defect in which every call site repeats a null check before the same operation. | https://banes-lab.com/json/records/lexicon/scattered-null-guards | https://banes-lab.com/records/lexicon/scattered-null-guards.md | 3159 | 5ffee368581483acba68a025283ffcaa27d5055a9b32edc1e779311582967fd8 |
| lexicon:complex-factory-hierarchies | anti-pattern | Complex Factory Hierarchies | Building elaborate parallel factory class hierarchies where cloning an existing configured instance would suffice. | https://banes-lab.com/json/records/lexicon/complex-factory-hierarchies | https://banes-lab.com/records/lexicon/complex-factory-hierarchies.md | 3228 | 47a57ab95cfed69ea06bf6a1f41b71e9c50e4744c862e81de2ccd9556295e962 |
| lexicon:concrete-constructor-coupling | anti-pattern | Concrete Constructor Coupling | Instantiating concrete classes directly with constructors, coupling callers to specific implementations. | https://banes-lab.com/json/records/lexicon/concrete-constructor-coupling | https://banes-lab.com/records/lexicon/concrete-constructor-coupling.md | 3698 | add098b026348f4d28295fcff8ab269e5812f607592dff4ea6a60a9786c1a22b |
| lexicon:global-mutable-state | anti-pattern | Global Mutable State | Exposing global variables that any code can mutate, creating hidden coupling and nondeterminism. | https://banes-lab.com/json/records/lexicon/global-mutable-state | https://banes-lab.com/records/lexicon/global-mutable-state.md | 4501 | c64e73f8dc56c6872d425adc54f438f02ef3dc80b010b576f87914a9907e7cc2 |
| lexicon:mixed-product-families | anti-pattern | Mixed Product Families | Combining products from different incompatible families, producing inconsistent sets of objects. | https://banes-lab.com/json/records/lexicon/mixed-product-families | https://banes-lab.com/records/lexicon/mixed-product-families.md | 3687 | 16f4063342fcc2f1177245b0aadc53bef5f5e9374dcea92ec15df6d6b0a93760 |
| lexicon:scattered-construction-logic | anti-pattern | Scattered Construction Logic | Spreading object-creation logic across many call sites instead of centralizing it in a factory. | https://banes-lab.com/json/records/lexicon/scattered-construction-logic | https://banes-lab.com/records/lexicon/scattered-construction-logic.md | 3605 | 54577b402e1a7e6c5ae5652bb93fa5e608479843f1821d0c38c3f359957498de |
| lexicon:telescoping-constructor | anti-pattern | Telescoping Constructor | Overloading constructors with ever more parameters to cover optional fields, producing unreadable call sites. | https://banes-lab.com/json/records/lexicon/telescoping-constructor | https://banes-lab.com/records/lexicon/telescoping-constructor.md | 3634 | e9e2bb4f60d9ba3799abd11d91923b9b303351257adcbd1e2bacf69151393e45 |
| lexicon:controlled-instantiation | capability | Controlled Instantiation | The ability to govern how and when an object is created. | https://banes-lab.com/json/records/lexicon/controlled-instantiation | https://banes-lab.com/records/lexicon/controlled-instantiation.md | 3134 | 6bf0b5abfa1778c376ea951083809df3edf1271aaad0efd84dddf15542120b76 |
| lexicon:deferred-instantiation | capability | Deferred Instantiation | The ability to let subclasses decide which class to instantiate, deferring the choice from the base class. | https://banes-lab.com/json/records/lexicon/deferred-instantiation | https://banes-lab.com/records/lexicon/deferred-instantiation.md | 3208 | baac4921d4976b696ff5c0b5ac8738bada28741925141dc6c84e7e0262a9ed23 |
| lexicon:dynamic-object-creation | capability | Dynamic Object Creation | The ability to create new objects at runtime by cloning existing configured instances. | https://banes-lab.com/json/records/lexicon/dynamic-object-creation | https://banes-lab.com/records/lexicon/dynamic-object-creation.md | 3162 | e4004fd75e003a4fcb5255ed99593f21fd6eb91b87c959d40f731c230e55dfa0 |
| lexicon:family-level-replacement | capability | Family-Level Replacement | The ability to swap an entire family of related products by changing a single factory. | https://banes-lab.com/json/records/lexicon/family-level-replacement | https://banes-lab.com/records/lexicon/family-level-replacement.md | 3206 | 598687537d1c44de5b27666cf7e621999a211a72eafbc5b24b543ceb3463923c |
| lexicon:polymorphic-construction | capability | Polymorphic Construction | The ability to create objects through a common interface without naming their concrete classes. | https://banes-lab.com/json/records/lexicon/polymorphic-construction | https://banes-lab.com/records/lexicon/polymorphic-construction.md | 3165 | 50bb5065332ca2fdaa48e41b72758018b16d5079d4fed72f778527a1de4a7a11 |
| lexicon:shared-resource-access | capability | Shared Resource Access | The ability to give many callers coordinated access to one shared resource. | https://banes-lab.com/json/records/lexicon/shared-resource-access | https://banes-lab.com/records/lexicon/shared-resource-access.md | 3142 | ee8af8a2969c18405cd2f0922c3d13673ed3e2fb6689379255575f402c665314 |
| lexicon:valid-object-creation | capability | Valid Object Creation | The ability to construct an object only once all its required parts are supplied and validated. | https://banes-lab.com/json/records/lexicon/valid-object-creation | https://banes-lab.com/records/lexicon/valid-object-creation.md | 3158 | c9f578c4450c67998fda2ed2561d974b16760f9272fa1f5cdc41b4a737fbbb24 |
| lexicon:cloneable-template-object | constraint | Cloneable Template Object | The requirement that a prototype object support being copied to produce new instances. | https://banes-lab.com/json/records/lexicon/cloneable-template-object | https://banes-lab.com/records/lexicon/cloneable-template-object.md | 3136 | 153902e17b8a7ceebd89ac5c1f5767c9fa67aa4cb33e0990f6e223663abe3566 |
| lexicon:creation-variation | constraint | Creation Variation | A precondition that different variants of a product must be produced depending on runtime context. | https://banes-lab.com/json/records/lexicon/creation-variation | https://banes-lab.com/records/lexicon/creation-variation.md | 3160 | 87c359c948115e6705f403e2f845380a7f043cc1a1eef2e0aa8be0000faf12de |
| lexicon:related-product-variants | constraint | Related Product Variants | The requirement that products form families of related variants meant to be used together. | https://banes-lab.com/json/records/lexicon/related-product-variants | https://banes-lab.com/records/lexicon/related-product-variants.md | 3166 | 4ead2b36e47fe67727aef7f1b5d9d11dad6e336f2b5d1c126f5fd8e3f70e2af1 |
| lexicon:single-instance-need | constraint | Single-Instance Need | A precondition that exactly one instance of a type must exist across the system. | https://banes-lab.com/json/records/lexicon/single-instance-need | https://banes-lab.com/records/lexicon/single-instance-need.md | 3175 | d8e7e90c32ec939c757e8189371408c1788324792c336b494e2539e5fcdc0aff |
| lexicon:subclass-controlled-creation | constraint | Subclass-Controlled Creation | The requirement that subclasses determine which concrete product a creator instantiates. | https://banes-lab.com/json/records/lexicon/subclass-controlled-creation | https://banes-lab.com/records/lexicon/subclass-controlled-creation.md | 3180 | 5a76f295054fad9df2780ff5b8d767f91ede8ea4da79c2deb52dc8580a71f6ec |
| lexicon:complex-construction | quality-attribute | Complex Construction | The degree of complexity in assembling an object that motivates a step-by-step builder. | https://banes-lab.com/json/records/lexicon/complex-construction | https://banes-lab.com/records/lexicon/complex-construction.md | 3129 | 7602e502e07ef079e57d103dfec3bd5f952ede155dbd6c84c6b585ae6811480a |
| lexicon:copy-semantics | quality-attribute | Copy Semantics | The degree of care required to define correct deep versus shallow copying when cloning objects. | https://banes-lab.com/json/records/lexicon/copy-semantics | https://banes-lab.com/records/lexicon/copy-semantics.md | 3915 | dcb214847a6812a662b65559d0f7a5915c628ee22006b6c758a7fc98bc382b44 |
| lexicon:inheritance-complexity | quality-attribute | Inheritance Complexity | The degree to which relying on subclassing to vary creation adds to the inheritance hierarchy's complexity. | https://banes-lab.com/json/records/lexicon/inheritance-complexity | https://banes-lab.com/records/lexicon/inheritance-complexity.md | 4024 | 7ab979ed4ee048abcc51307758a8a8875ba8dff568b700a56aedde7655fc9edf |
| lexicon:constructor-valid-state | technique | Constructor-Valid State | A technique for having a constructor or factory accept only arguments that produce a valid object. | https://banes-lab.com/json/records/lexicon/constructor-valid-state | https://banes-lab.com/records/lexicon/constructor-valid-state.md | 3142 | 08b4aa5fdc4005e86c6506df0548d8e72ca99c9e84ad058e8326fe5b0919c33b |
| lexicon:repeated-expensive-setup | anti-pattern | Repeated Expensive Setup | A defect in which each new object repeats a costly setup that copying a prepared instance would avoid. | https://banes-lab.com/json/records/lexicon/repeated-expensive-setup | https://banes-lab.com/records/lexicon/repeated-expensive-setup.md | 3222 | b8a76f698a28c16a3d2ed441da69766f02df8198e9e6a19549aa31363db39eb1 |
| lexicon:cartesian-inheritance-explosion | anti-pattern | Cartesian Inheritance Explosion | Modeling every combination of two independent dimensions as its own subclass, so the class count grows multiplicatively. | https://banes-lab.com/json/records/lexicon/cartesian-inheritance-explosion | https://banes-lab.com/records/lexicon/cartesian-inheritance-explosion.md | 3592 | b028a1576af7cc3dfad22f1a83b27b70733292bfa2d9a6bc9834283defea0e20 |
| lexicon:direct-access | anti-pattern | Direct Access | Reaching a resource directly with no intermediary, bypassing the access control, caching, or laziness a proxy would add. | https://banes-lab.com/json/records/lexicon/direct-access | https://banes-lab.com/records/lexicon/direct-access.md | 3600 | 35cc5e7f78df2adb1cf09850f1b0a3a9a320ce9d51e4b7242fcc6b4927039a17 |
| lexicon:direct-external-coupling | anti-pattern | Direct External Coupling | Coupling code directly to an incompatible external interface, spreading its idiosyncrasies through the codebase. | https://banes-lab.com/json/records/lexicon/direct-external-coupling | https://banes-lab.com/records/lexicon/direct-external-coupling.md | 4454 | 680035cfb5ee3e6be2b7e81ab4552c85b07d9204035b22a764d8ccd41c53cba3 |
| lexicon:leaf-vs-container-special-casing | anti-pattern | Leaf-vs-Container Special-Casing | Branching client code on whether an element is a leaf or a container instead of treating them through one interface. | https://banes-lab.com/json/records/lexicon/leaf-vs-container-special-casing | https://banes-lab.com/records/lexicon/leaf-vs-container-special-casing.md | 3652 | f9c0f2a2989ba491f844273f33583b6c5308ffd6df6ec7e01cab2255830f722a |
| lexicon:leaky-subsystem-api | anti-pattern | Leaky Subsystem API | Exposing a subsystem's internal complexity directly to clients instead of hiding it behind a simplifying interface. | https://banes-lab.com/json/records/lexicon/leaky-subsystem-api | https://banes-lab.com/records/lexicon/leaky-subsystem-api.md | 3654 | 1133e79db512201c1f170dad47fb0908cb312b0039431d1b44359da25376f083 |
| lexicon:per-instance-duplicate-state | anti-pattern | Per-Instance Duplicate State | Storing identical shared state separately in every object instance, wasting memory at high object counts. | https://banes-lab.com/json/records/lexicon/per-instance-duplicate-state | https://banes-lab.com/records/lexicon/per-instance-duplicate-state.md | 3595 | 01a56fc10b386160845ff337c0a866f8e962ecd000af59a42c83d3305754426d |
| lexicon:subclass-explosion | anti-pattern | Subclass Explosion | Creating a distinct subclass for every combination of optional features instead of composing them at runtime. | https://banes-lab.com/json/records/lexicon/subclass-explosion | https://banes-lab.com/records/lexicon/subclass-explosion.md | 3659 | 58707b36d0c147a4e5457c84b94ee881663d38c63fa9f498ba389d9a31db5d55 |
| lexicon:high-cardinality-object-reuse | capability | High-Cardinality Object Reuse | The ability to represent large numbers of similar objects economically by sharing their common intrinsic state. | https://banes-lab.com/json/records/lexicon/high-cardinality-object-reuse | https://banes-lab.com/records/lexicon/high-cardinality-object-reuse.md | 3614 | 9a1052413b234dfe3baef11e5cca21d80b5b6c21a6248d3c8d045d641aedbf2b |
| lexicon:implementation-swap | capability | Implementation Swap | The ability to change an abstraction's underlying implementation without altering the abstraction itself. | https://banes-lab.com/json/records/lexicon/implementation-swap | https://banes-lab.com/records/lexicon/implementation-swap.md | 3110 | 09eb34340325580aa5d2cf79621a5f32c8e63cb44ec79b898a0eda12eefbd7b7 |
| lexicon:lazy-load | capability | Lazy Load | The ability to defer creating or loading a costly resource until it is first used. | https://banes-lab.com/json/records/lexicon/lazy-load | https://banes-lab.com/records/lexicon/lazy-load.md | 3082 | cfb29e6909ed69467408130ad127a31ffb4e5f9e63409d0de3f626755fa85138 |
| lexicon:leaf-composite-transparency | capability | Leaf/Composite Transparency | The ability to treat individual objects and compositions of objects through one uniform interface. | https://banes-lab.com/json/records/lexicon/leaf-composite-transparency | https://banes-lab.com/records/lexicon/leaf-composite-transparency.md | 3558 | 2413ba65f9db648233d5d91d7342fcf0a6fd5d9a8107380bf962844bd32656ea |
| lexicon:recursive-composition | capability | Recursive Composition | The ability to build tree structures in which composites contain other composites to arbitrary depth. | https://banes-lab.com/json/records/lexicon/recursive-composition | https://banes-lab.com/records/lexicon/recursive-composition.md | 3204 | 4e4b7fc1347334f427ef5bfa0767e5e32980f8d258c07553f4a7b45ed586a2b2 |
| lexicon:runtime-behavior-extension | capability | Runtime Behavior Extension | The ability to add responsibilities to an object dynamically at runtime by wrapping it. | https://banes-lab.com/json/records/lexicon/runtime-behavior-extension | https://banes-lab.com/records/lexicon/runtime-behavior-extension.md | 3160 | a9ee1fb492a4e48b9dab403603ecf572f58fbe3c62b8d0f163d6be7831a741b3 |
| lexicon:shared-immutable-state | capability | Shared Immutable State | The ability to safely share one immutable state object across many contexts at once. | https://banes-lab.com/json/records/lexicon/shared-immutable-state | https://banes-lab.com/records/lexicon/shared-immutable-state.md | 3141 | e14dd1f984adf63b1f6ad6a9a0e11a3921cde85bf48c2844750d2430678e0d0d |
| lexicon:simplified-access | capability | Simplified Access | The ability to use a complex subsystem through a small, convenient interface. | https://banes-lab.com/json/records/lexicon/simplified-access | https://banes-lab.com/records/lexicon/simplified-access.md | 3049 | 2b75343f6f347209408727dfbd5efca8d050c93ef71ef9cea4e74033b73de9f4 |
| lexicon:remote-stub | mechanism | Remote Stub | A local stand-in object that forwards calls to an object living in another process or machine. | https://banes-lab.com/json/records/lexicon/remote-stub | https://banes-lab.com/records/lexicon/remote-stub.md | 3595 | 5aaad38f9f4dcf726c9b0bb903b0666e82bde119d69258b0616a97c0078464bf |
| lexicon:common-interface | constraint | Common Interface | The requirement that a wrapper and the object it wraps share one interface so they remain interchangeable. | https://banes-lab.com/json/records/lexicon/common-interface | https://banes-lab.com/records/lexicon/common-interface.md | 3095 | 850cb64cc2f2827e4a4e1733ed315bed93dd740bcf9f1833ea43d74de56d9853 |
| lexicon:incompatible-interfaces | constraint | Incompatible Interfaces | A precondition of two interfaces that must cooperate yet expose mismatched signatures. | https://banes-lab.com/json/records/lexicon/incompatible-interfaces | https://banes-lab.com/records/lexicon/incompatible-interfaces.md | 3133 | d0a7528a8efd85fd9ef173f8e9ff492123ff0d6d72104414536fb53a4295f78d |
| lexicon:independent-variation-axes | constraint | Independent Variation Axes | The requirement that an abstraction and its implementation vary along separate axes so they can be decoupled. | https://banes-lab.com/json/records/lexicon/independent-variation-axes | https://banes-lab.com/records/lexicon/independent-variation-axes.md | 3193 | 69d8d677e2a603505fed727c398fd015349dbecd1e60a971f2aab716dc8b6e37 |
| lexicon:separable-intrinsic-state | constraint | Separable Intrinsic State | The requirement that an object's shared, context-independent state be separable from its per-use state. | https://banes-lab.com/json/records/lexicon/separable-intrinsic-state | https://banes-lab.com/records/lexicon/separable-intrinsic-state.md | 3223 | f95baefb35f8861bac5faae86729beb73c88f17fbdb0accb92a4035a783566da |
| lexicon:uniform-component-interface | constraint | Uniform Component Interface | The requirement that leaves and composites implement one shared interface so clients treat them alike. | https://banes-lab.com/json/records/lexicon/uniform-component-interface | https://banes-lab.com/records/lexicon/uniform-component-interface.md | 3145 | 05bbb4d10924323f5fe69d2f2f96d5abd607df2bc50be8b5f07a42d8d879483c |
| lexicon:indirection | quality-attribute | Indirection | The degree of extra indirection introduced by separating an abstraction from its implementation. | https://banes-lab.com/json/records/lexicon/indirection | https://banes-lab.com/records/lexicon/indirection.md | 3879 | 1a941c82c842dea63b573dc3bae41e5867873e46e1ad73478c5831ce6acd59bc |
| lexicon:over-centralization | quality-attribute | Over-Centralization | The degree to which routing all access through one facade concentrates responsibility and can bottleneck change. | https://banes-lab.com/json/records/lexicon/over-centralization | https://banes-lab.com/records/lexicon/over-centralization.md | 3867 | b076874caa96cb3f4e5a28f4fea26f35ecf1ccdd4c08a13252ab2368f86f44dd |
| lexicon:stack-debugging | quality-attribute | Stack Debugging | The degree to which layers of wrapping deepen the call stack and complicate debugging. | https://banes-lab.com/json/records/lexicon/stack-debugging | https://banes-lab.com/records/lexicon/stack-debugging.md | 3900 | 655eedf78ab4315b3b2311dfa7396a1e9439e4cc3437e2a3539d57c99f25af8e |
| lexicon:subsystem-complexity | quality-attribute | Subsystem Complexity | The degree of internal complexity in a subsystem that motivates hiding it behind a facade. | https://banes-lab.com/json/records/lexicon/subsystem-complexity | https://banes-lab.com/records/lexicon/subsystem-complexity.md | 3104 | 6dc04605c98eec01f40f2fcf34fd5c53ebccd2f010d64f1d5d0b3cbbde2b8a20 |
| lexicon:transparency-debugging | quality-attribute | Transparency / Debugging | The degree to which interposing a proxy hides the real object and complicates tracing calls to it. | https://banes-lab.com/json/records/lexicon/transparency-debugging | https://banes-lab.com/records/lexicon/transparency-debugging.md | 3984 | 19825492e4b1a5d923de623d29b770475cc4eeb42e8aac6626726d94663e7224 |
| lexicon:anecdotal-performance-claims | anti-pattern | Anecdotal Performance Claims | Asserting performance characteristics from anecdote or intuition rather than measured evidence. | https://banes-lab.com/json/records/lexicon/anecdotal-performance-claims | https://banes-lab.com/records/lexicon/anecdotal-performance-claims.md | 3710 | b72d7d8c3d77c5493a5a61cfdfd42d697c895b630bbcfd70c65c3e4062d4a04a |
| lexicon:anecdotal-timing | anti-pattern | Anecdotal Timing | Judging how fast code runs from casual observation instead of controlled measurement. | https://banes-lab.com/json/records/lexicon/anecdotal-timing | https://banes-lab.com/records/lexicon/anecdotal-timing.md | 3233 | 46d1a9b328fb58ad8987fc70214675788a0da1aed843d5ab1490197b4254bf01 |
| lexicon:bottlenecks | anti-pattern | Bottlenecks | A single stage that constrains overall throughput because all work must pass through it. | https://banes-lab.com/json/records/lexicon/bottlenecks | https://banes-lab.com/records/lexicon/bottlenecks.md | 3923 | c4a17ce8d06c9ea9abc3a334dbbb44bbaddc4cd2343d1c3122f8128ade704235 |
| lexicon:fixed-provisioning | anti-pattern | Fixed Provisioning | Allocating a static amount of capacity regardless of demand, so the system is either starved or wasteful. | https://banes-lab.com/json/records/lexicon/fixed-provisioning | https://banes-lab.com/records/lexicon/fixed-provisioning.md | 3618 | 877cd31094b174465b33111bf1ba2643f0c2bc3b6910075916ed584e86b9d177 |
| lexicon:fixed-capacity-design | anti-pattern | Fixed-Capacity Design | Building a system around a fixed capacity ceiling that cannot grow when load increases. | https://banes-lab.com/json/records/lexicon/fixed-capacity-design | https://banes-lab.com/records/lexicon/fixed-capacity-design.md | 4219 | 8907a3d5f4cd1bde1238d5a631108b17077e7f8a3ef9df8613d1e3a4b169991d |
| lexicon:full-materialization | anti-pattern | Full Materialization | Loading an entire dataset into memory at once when streaming or chunking would suffice, risking exhaustion. | https://banes-lab.com/json/records/lexicon/full-materialization | https://banes-lab.com/records/lexicon/full-materialization.md | 4680 | 6b3f773de2a0bcd9ca5672b71778b1a15289c7c91959624e1dcd19c0a1b390bd |
| lexicon:global-shared-state | anti-pattern | Global Shared State | A single mutable state shared across all workers, forcing coordination and preventing independent scaling. | https://banes-lab.com/json/records/lexicon/global-shared-state | https://banes-lab.com/records/lexicon/global-shared-state.md | 3271 | fe0bf8f1e708a5405bea76f543906fa5eb18eca149d49a2ab837ddb57d668dfa |
| lexicon:guess-based-capacity | anti-pattern | Guess-Based Capacity | Sizing capacity from guesswork rather than a model of arrival and service rates. | https://banes-lab.com/json/records/lexicon/guess-based-capacity | https://banes-lab.com/records/lexicon/guess-based-capacity.md | 3696 | afd4a2a1a64741f26e14b463dcd72899b5843aa4cf63872d13076277d4684db3 |
| lexicon:guess-based-optimization | anti-pattern | Guess-Based Optimization | Optimizing based on assumptions about where time is spent rather than profiling evidence. | https://banes-lab.com/json/records/lexicon/guess-based-optimization | https://banes-lab.com/records/lexicon/guess-based-optimization.md | 3741 | 9c7f928de0e1d11462258cc55ddf5b268fc37df0747af5fb7956fd71d88e59e4 |
| lexicon:guesswork | anti-pattern | Guesswork | Deciding where to optimize by intuition instead of measured profiling data. | https://banes-lab.com/json/records/lexicon/guesswork | https://banes-lab.com/records/lexicon/guesswork.md | 3607 | 270b9a7ae1da408704408adb542505bcc55b532778f5348e39678cbd0fb2ea6c |
| lexicon:hard-resource-ceiling | anti-pattern | Hard Resource Ceiling | A fixed upper bound on a single machine's resources that caps how far vertical scaling can go. | https://banes-lab.com/json/records/lexicon/hard-resource-ceiling | https://banes-lab.com/records/lexicon/hard-resource-ceiling.md | 3704 | 0c54d9cb8e6be544c5e600cc3444a1009a1010760fbdf20290902dae29f62d85 |
| lexicon:inefficient-algorithm-choice | anti-pattern | Inefficient Algorithm Choice | Selecting an algorithm whose complexity scales poorly for the expected input size. | https://banes-lab.com/json/records/lexicon/inefficient-algorithm-choice | https://banes-lab.com/records/lexicon/inefficient-algorithm-choice.md | 4500 | eda8670619f4f89290a95976a066b430be26510aaada9a08763282f362fb99a7 |
| lexicon:instance-affinity | anti-pattern | Instance Affinity | Binding a client to a specific server instance for its state, preventing free rebalancing across instances. | https://banes-lab.com/json/records/lexicon/instance-affinity | https://banes-lab.com/records/lexicon/instance-affinity.md | 3751 | fb0bb32b7949b9541755db219ba56925c196e61274fc57054328962ab7190810 |
| lexicon:instance-local-state | anti-pattern | Instance-Local State | Holding request-spanning state on one instance, so requests cannot be served by any other instance. | https://banes-lab.com/json/records/lexicon/instance-local-state | https://banes-lab.com/records/lexicon/instance-local-state.md | 3720 | 55331f826e79b894b10f87c2c8c7d92a36ada62365e54b1fbd22fae85f7098dd |
| lexicon:local-micro-optimization | anti-pattern | Local Micro-Optimization | Tuning a non-bottleneck section for marginal gains while the constraint that limits performance goes unaddressed. | https://banes-lab.com/json/records/lexicon/local-micro-optimization | https://banes-lab.com/records/lexicon/local-micro-optimization.md | 3770 | 5c7196395e7966af2ca2c990adababebde9bd605dd80e5d204e8a161f7a1fec4 |
| lexicon:long-blocking-work | anti-pattern | Long Blocking Work | Performing lengthy synchronous work on a request path, blocking it and inflating latency. | https://banes-lab.com/json/records/lexicon/long-blocking-work | https://banes-lab.com/records/lexicon/long-blocking-work.md | 3627 | df7612792000371677c3e0e5c17534363b4edc1a3cf23cdf8ed241a477d69c91 |
| lexicon:origin-only-serving | anti-pattern | Origin-Only Serving | Serving all content directly from the origin with no edge caching, concentrating load and adding distance latency. | https://banes-lab.com/json/records/lexicon/origin-only-serving | https://banes-lab.com/records/lexicon/origin-only-serving.md | 3735 | bc64ad728b4c206f28b9ffa261a82f5bc7ac51cce8c617239c0cd4793c34cb94 |
| lexicon:premature-optimization | anti-pattern | Premature Optimization | Optimizing code before evidence shows it matters, adding complexity for gains that may never be needed. | https://banes-lab.com/json/records/lexicon/premature-optimization | https://banes-lab.com/records/lexicon/premature-optimization.md | 3712 | 0e1c462e30096a91bf74a27c9add564aaea0e8bb4ebe435b9cfd6889e2357c3a |
| lexicon:resource-waste-saturation | anti-pattern | Resource Waste/Saturation | Running resources far below or far above healthy utilization, either wasting capacity or saturating it. | https://banes-lab.com/json/records/lexicon/resource-waste-saturation | https://banes-lab.com/records/lexicon/resource-waste-saturation.md | 4427 | 29fb3f55f0c67c0007971519e6817ffb642fefdf8475df0542b34e0dc8f63a56 |
| lexicon:sequential-bottleneck | anti-pattern | Sequential Bottleneck | A portion of work that must run serially, capping the speedup that parallelism can achieve. | https://banes-lab.com/json/records/lexicon/sequential-bottleneck | https://banes-lab.com/records/lexicon/sequential-bottleneck.md | 4618 | 2e72fc91d140f4374dd255f2e265745b3718a270f6305447152c9e1fae5b01a4 |
| lexicon:single-monolithic-store | anti-pattern | Single Monolithic Store | Concentrating all data in one store that cannot be partitioned, capping write and storage scalability. | https://banes-lab.com/json/records/lexicon/single-monolithic-store | https://banes-lab.com/records/lexicon/single-monolithic-store.md | 4010 | 8012110dc664a9546507dd83b9c3e8107cbc15d80b330bd01b63588b088b454c |
| lexicon:single-target-routing | anti-pattern | Single Target Routing | Directing all traffic to one target instead of distributing it, wasting capacity and creating a bottleneck. | https://banes-lab.com/json/records/lexicon/single-target-routing | https://banes-lab.com/records/lexicon/single-target-routing.md | 3777 | ccf42a554d9d3281c7791b9450f1586a9263d5fe41ba2cfb62db55fdaacdcd96 |
| lexicon:single-primary-read-contention | anti-pattern | Single-Primary Read Contention | Serving all reads from the single primary, so read load contends with writes and limits throughput. | https://banes-lab.com/json/records/lexicon/single-primary-read-contention | https://banes-lab.com/records/lexicon/single-primary-read-contention.md | 3705 | 78f4eb5327a546bdc719b301e4d47fd97cb189168023cf6de5c1c4d5fd47d987 |
| lexicon:unbounded-access | anti-pattern | Unbounded Access | Permitting callers to make unlimited requests with no rate limit, allowing overload and abuse. | https://banes-lab.com/json/records/lexicon/unbounded-access | https://banes-lab.com/records/lexicon/unbounded-access.md | 3734 | 7b38abc2871622c28d23b0108b4d0ba4b12784e79dad089ae8c1c75a1c0bc2c4 |
| lexicon:unbounded-memory-growth | anti-pattern | Unbounded Memory Growth | Accumulating state without bound so memory usage grows until the process exhausts it. | https://banes-lab.com/json/records/lexicon/unbounded-memory-growth | https://banes-lab.com/records/lexicon/unbounded-memory-growth.md | 4088 | 19f3a109aeae75c0cf44f17414a3f760a3f93cc1ceb3cf790462b1bced1d3b14 |
| lexicon:unbounded-runtime-growth | anti-pattern | Unbounded Runtime Growth | An algorithm whose running time grows without bound as input scales, becoming infeasible at size. | https://banes-lab.com/json/records/lexicon/unbounded-runtime-growth | https://banes-lab.com/records/lexicon/unbounded-runtime-growth.md | 3337 | b5c0612420aaafca350df02c0994e244bffecc1a4c01a2bfa309dc39ff442e47 |
| lexicon:arrival-and-service-rates | metric | Arrival and Service Rates | The measured rates at which requests arrive and at which a server completes them, the inputs a queuing model needs. | https://banes-lab.com/json/records/lexicon/arrival-and-service-rates | https://banes-lab.com/records/lexicon/arrival-and-service-rates.md | 3329 | 865ea29845e5b77f759300ed300b0e871d378f443407b1e8676b83f59d1a6d65 |
| lexicon:bottleneck-awareness | capability | Bottleneck Awareness | The ability to recognize which component limits a system's overall throughput. | https://banes-lab.com/json/records/lexicon/bottleneck-awareness | https://banes-lab.com/records/lexicon/bottleneck-awareness.md | 3261 | 747f077c5749e07d3a0e758f50b95afc53dede8053cbc5fb9e7b553db7463857 |
| lexicon:bottleneck-evidence | artifact | Bottleneck Evidence | Measured data identifying which component constrains performance, justifying where to optimize. | https://banes-lab.com/json/records/lexicon/bottleneck-evidence | https://banes-lab.com/records/lexicon/bottleneck-evidence.md | 3242 | e6cbc5aea92bf8cf1dda0b771e3977dc4101759e0a4a0c27b24b1f51c455e1ea |
| lexicon:cacheable-content | constraint | Cacheable Content | The requirement that content be stable enough to serve from a cache without harmful staleness. | https://banes-lab.com/json/records/lexicon/cacheable-content | https://banes-lab.com/records/lexicon/cacheable-content.md | 3237 | 28425e485ad144edf8e7d2261f6a31770eea07ac2e2ee820cf3ae89ea282d3c8 |
| lexicon:capacity-model | model | Capacity Model | A representation of how a system's capacity responds to load, used to predict its limits. | https://banes-lab.com/json/records/lexicon/capacity-model | https://banes-lab.com/records/lexicon/capacity-model.md | 3203 | 6ba1178c295c5769328b88a037dc05bf55e606b0018654e41cd4dd872616bf10 |
| lexicon:complexity-awareness | capability | Complexity Awareness | The ability to reason about how an algorithm's cost grows with input size. | https://banes-lab.com/json/records/lexicon/complexity-awareness | https://banes-lab.com/records/lexicon/complexity-awareness.md | 3242 | 0ad297641c22acc32e106b73523820cf5bc6c5f8eb32326d411a7b8d6289eafb |
| lexicon:complexity-model | model | Complexity Model | A representation of how an algorithm's resource use scales with input size. | https://banes-lab.com/json/records/lexicon/complexity-model | https://banes-lab.com/records/lexicon/complexity-model.md | 3222 | e5fac5045d07550ca8b1458b18d803d28da80535ff721dc09c7f7de43e2a50f6 |
| lexicon:externalized-state | constraint | Externalized State | The requirement that session or request state be held outside the serving instance, in a shared store. | https://banes-lab.com/json/records/lexicon/externalized-state | https://banes-lab.com/records/lexicon/externalized-state.md | 3227 | 7093cd2cf87a55814b5a76cd289c1a434fbda56021c3a4baedb5a441e2e0b8e8 |
| lexicon:input-size-model | model | Input Size Model | A representation of the input dimension against which an algorithm's running time is measured. | https://banes-lab.com/json/records/lexicon/input-size-model | https://banes-lab.com/records/lexicon/input-size-model.md | 3241 | a48d29baf19bab84a5642af0b3cfbd66e5c1c6e92f47f66fad21f8ecf3cfea48 |
| lexicon:invalidation-policy | constraint | Invalidation Policy | The rules determining when cached entries are considered stale and must be refreshed or evicted. | https://banes-lab.com/json/records/lexicon/invalidation-policy | https://banes-lab.com/records/lexicon/invalidation-policy.md | 3165 | 85539c1bcc451c835da0873c1a81fccab44f2588d3e45a00928603be73ab5b25 |
| lexicon:load-model | model | Load Model | A representation of the expected volume and pattern of demand a system must handle. | https://banes-lab.com/json/records/lexicon/load-model | https://banes-lab.com/records/lexicon/load-model.md | 3156 | bac7280935a35acfdeee685dbcceea9b61a940468e6414fba1c14d07c373341f |
| lexicon:memory-model | model | Memory Model | A representation of how an algorithm's memory use grows with input size. | https://banes-lab.com/json/records/lexicon/memory-model | https://banes-lab.com/records/lexicon/memory-model.md | 3153 | 964ea0bee7a065d516166ab20655447d050ffa6220a3a30ab0b5e1a333c35b6e |
| lexicon:multiple-targets | constraint | Multiple Targets | The precondition that more than one interchangeable backend exists across which traffic can be spread. | https://banes-lab.com/json/records/lexicon/multiple-targets | https://banes-lab.com/records/lexicon/multiple-targets.md | 3189 | cd43286e4a66d048aa70c6ad9b8691c0bf8c2c8352d12df013203a1cb1e88c98 |
| lexicon:partition-key | artifact | Partition Key | The field whose value determines which shard or partition a record belongs to. | https://banes-lab.com/json/records/lexicon/partition-key | https://banes-lab.com/records/lexicon/partition-key.md | 3166 | 01f462736009cb2a5fa3ceca10ba72aaf0f1bc01642fa09f792454b664bb3213 |
| lexicon:partition-strategy | approach | Partition Strategy | A scheme for dividing data or work across independent partitions to distribute load and enable parallelism. | https://banes-lab.com/json/records/lexicon/partition-strategy | https://banes-lab.com/records/lexicon/partition-strategy.md | 3190 | 9d03b4d5a1a2d036aa8c669415f55b1c9961ef0614b4fbd75ab0d1ca4a3e78bc |
| lexicon:quota-policy | constraint | Quota Policy | The declared limits on how many requests a caller may make within a time window. | https://banes-lab.com/json/records/lexicon/quota-policy | https://banes-lab.com/records/lexicon/quota-policy.md | 3246 | abcccf3cf342541e4164d549c706327d6fa4a64bbbac94a800a612c4983fb61f |
| lexicon:repeatable-test-environment | constraint | Repeatable Test Environment | A controlled, reproducible environment in which measurements can be compared meaningfully across runs. | https://banes-lab.com/json/records/lexicon/repeatable-test-environment | https://banes-lab.com/records/lexicon/repeatable-test-environment.md | 3273 | 632ad4e35c255feea94c368d5abe40b2a7fdbdc9dc46d0a5635b7a35972c6f48 |
| lexicon:representative-workload | constraint | Representative Workload | A workload that reflects production usage closely enough that measurements generalize. | https://banes-lab.com/json/records/lexicon/representative-workload | https://banes-lab.com/records/lexicon/representative-workload.md | 3271 | 3b9693ef02e2721c65fa7a1830d307757c0387ea37cc9d0f56db6a2df00d5aa5 |
| lexicon:resource-headroom | quality-attribute | Resource Headroom | The degree of spare capacity remaining on a machine before its resource ceiling is reached. | https://banes-lab.com/json/records/lexicon/resource-headroom | https://banes-lab.com/records/lexicon/resource-headroom.md | 3319 | 4d99f12c93e2a2feb6888dd0a3e26a6706e03d2d95151c82de721ed0f44d1c13 |
| lexicon:space-complexity-awareness | capability | Space Complexity Awareness | The ability to reason about how an algorithm's memory use grows with input size. | https://banes-lab.com/json/records/lexicon/space-complexity-awareness | https://banes-lab.com/records/lexicon/space-complexity-awareness.md | 3372 | f8e442595e02f1dbfd2cf248c8b27ec465d90ce70457761580355c36e3625b12 |
| lexicon:statelessness-or-shared-state-strategy | approach | Statelessness or Shared State Strategy | A decision to make instances stateless or externalize state to a shared store, so any instance can serve any request. | https://banes-lab.com/json/records/lexicon/statelessness-or-shared-state-strategy | https://banes-lab.com/records/lexicon/statelessness-or-shared-state-strategy.md | 3440 | d10d1b005b1561b333a3635c67915b9ac325dc4545580c020a0ab22015a09f46 |
| lexicon:abuse-overload-protection | capability | Abuse/Overload Protection | The ability to shield a system from abusive or excessive request volume. | https://banes-lab.com/json/records/lexicon/abuse-overload-protection | https://banes-lab.com/records/lexicon/abuse-overload-protection.md | 3354 | 22c2a35390a758443738f7b45cf954a0e8d0d78498a9a0b1c1a4cd9d137a7f60 |
| lexicon:bottleneck-detection | capability | Bottleneck Detection | The ability to locate the component that most constrains overall performance. | https://banes-lab.com/json/records/lexicon/bottleneck-detection | https://banes-lab.com/records/lexicon/bottleneck-detection.md | 3344 | 6b3dde2b14ff5d5ab457483436dfadaddcc186c301597db4b11df54b47df68e4 |
| lexicon:capacity-increase-without-distribution | capability | Capacity Increase without Distribution | The ability to raise capacity by enlarging a single machine rather than adding more machines. | https://banes-lab.com/json/records/lexicon/capacity-increase-without-distribution | https://banes-lab.com/records/lexicon/capacity-increase-without-distribution.md | 3352 | 3021502b9a8cec5cd5f9efa3682d55837999835e80b76f577f2a246d9674cb8f |
| lexicon:comparative-analysis | capability | Comparative Analysis | The ability to compare algorithms by how their cost grows, independent of hardware. | https://banes-lab.com/json/records/lexicon/comparative-analysis | https://banes-lab.com/records/lexicon/comparative-analysis.md | 3325 | 96d451bcbbcd694d395353d2ee7dd4b69926b1835ac83a92ec87a6d5f10183f1 |
| lexicon:cost-efficiency | quality-attribute | Cost Efficiency | The degree to which a system delivers its work at the lowest resource cost. | https://banes-lab.com/json/records/lexicon/cost-efficiency | https://banes-lab.com/records/lexicon/cost-efficiency.md | 3202 | e55700d34bfc0e7eba9985fe65b22078645427748b252e814ff1a51bd469a037 |
| lexicon:dynamic-capacity | capability | Dynamic Capacity | The ability to add or remove capacity automatically as demand rises and falls. | https://banes-lab.com/json/records/lexicon/dynamic-capacity | https://banes-lab.com/records/lexicon/dynamic-capacity.md | 3194 | f0ba5bc3ea1bb01b45ceeb433c189b2fcbcc6cbc93a499befc90c328bc0298c8 |
| lexicon:efficient-processing | capability | Efficient Processing | The ability to complete work using the fewest operations and least resource for the input. | https://banes-lab.com/json/records/lexicon/efficient-processing | https://banes-lab.com/records/lexicon/efficient-processing.md | 3332 | 369d779c20bc4a17aa7bee2778c83ab266af09b1134440a2a4144265f2084728 |
| lexicon:geographically-local-delivery | capability | Geographically-Local Delivery | The ability to serve content from a location near the user, cutting distance latency. | https://banes-lab.com/json/records/lexicon/geographically-local-delivery | https://banes-lab.com/records/lexicon/geographically-local-delivery.md | 3822 | 2f7339a7db35036249284253f5dbc16a65817f8653113958e6b4894136b0529d |
| lexicon:growth-handling | capability | Growth Handling | The ability to absorb increasing load without redesign. | https://banes-lab.com/json/records/lexicon/growth-handling | https://banes-lab.com/records/lexicon/growth-handling.md | 3247 | 49b66097e07376c01db4de06e72dffbd3c86b42bed3ab637ca58216a833164b6 |
| lexicon:large-dataset-scaling | capability | Large Dataset Scaling | The ability to grow storage and throughput by spreading a dataset across many shards. | https://banes-lab.com/json/records/lexicon/large-dataset-scaling | https://banes-lab.com/records/lexicon/large-dataset-scaling.md | 3196 | 839329a52378649711ce0f9f2a51212829f7130fbe27a3e5d6f2b71977ee1ead |
| lexicon:latency-reduction | capability | Latency Reduction | The ability to lower response time by serving results from a nearer or faster source. | https://banes-lab.com/json/records/lexicon/latency-reduction | https://banes-lab.com/records/lexicon/latency-reduction.md | 3188 | 23e4776d1ad401f40b5a0a86fe3ced5fdae715eec82a17f52531242d7f89c119 |
| lexicon:load-handling | capability | Load Handling | The ability to process a high volume of work without degrading. | https://banes-lab.com/json/records/lexicon/load-handling | https://banes-lab.com/records/lexicon/load-handling.md | 3167 | e23a4f535b43932cc7bd398ec3f1fed6c5097a404fda1800092bbc93a57a2b2a |
| lexicon:memory-scalability | capability | Memory Scalability | The ability to handle larger inputs without memory use growing prohibitively. | https://banes-lab.com/json/records/lexicon/memory-scalability | https://banes-lab.com/records/lexicon/memory-scalability.md | 3231 | ed88f38b7da3d96d2bc8e86a0baac82d90aa735d5ebd24f58c7a7b7ca76ca61b |
| lexicon:multi-core-utilization | capability | Multi-Core Utilization | The ability to use multiple processor cores simultaneously for a single workload. | https://banes-lab.com/json/records/lexicon/multi-core-utilization | https://banes-lab.com/records/lexicon/multi-core-utilization.md | 3211 | a7223057e777fb6adce08728e368da5874836d6f3f14f88be729f970390e76cf |
| lexicon:origin-offload | capability | Origin Offload | The ability to relieve the origin server by serving cached copies from the edge. | https://banes-lab.com/json/records/lexicon/origin-offload | https://banes-lab.com/records/lexicon/origin-offload.md | 3235 | 412d53d56150b24fc37aaee5c7882556e48c9d2e09d00727ae3916d17976d136 |
| lexicon:overlapping-work | capability | Overlapping Work | The ability to make progress on multiple tasks over the same period by interleaving them. | https://banes-lab.com/json/records/lexicon/overlapping-work | https://banes-lab.com/records/lexicon/overlapping-work.md | 3205 | f1e2ffbadc21972d3ceee371e3a1e23c9c62a85d67bc6b9fe43b7921f53596c7 |
| lexicon:read-traffic-offload | capability | Read Traffic Offload | The ability to divert read queries to replicas, relieving the primary. | https://banes-lab.com/json/records/lexicon/read-traffic-offload | https://banes-lab.com/records/lexicon/read-traffic-offload.md | 3177 | 296b1c24a2dd9abd9a3d9387e43ac1e8865ac33c531dc20f30aef1eafaa02a35 |
| lexicon:reduced-load | capability | Reduced Load | The ability to lessen work reaching a backend by serving repeat results from a cache. | https://banes-lab.com/json/records/lexicon/reduced-load | https://banes-lab.com/records/lexicon/reduced-load.md | 3195 | e1350453c488f0ecb65b32572e13585005f075463816330b160118fdf230e270 |
| lexicon:regression-detection | capability | Regression Detection | The ability to catch a performance regression by comparing measurements against a baseline. | https://banes-lab.com/json/records/lexicon/regression-detection | https://banes-lab.com/records/lexicon/regression-detection.md | 3188 | 81d040796c2829acfdf6fb3b0094af36a4179bcdc9c1208196ad560c081b8f75 |
| lexicon:responsiveness | quality-attribute | Responsiveness | The degree to which a system reacts quickly to user actions or requests. | https://banes-lab.com/json/records/lexicon/responsiveness | https://banes-lab.com/records/lexicon/responsiveness.md | 3197 | 65d681940963658d3de17a72a56da66f6323a5f8b9dc1d60eb9664877de1252b |
| lexicon:scalability-analysis | activity | Scalability Analysis | The activity of assessing how a system's cost grows as load or input increases. | https://banes-lab.com/json/records/lexicon/scalability-analysis | https://banes-lab.com/records/lexicon/scalability-analysis.md | 3174 | ab66d0f8cda68cac25479d9452fd5013cd76ce429e28bccabe13b59e8d145b23 |
| lexicon:scale-out | capability | Scale-Out | The ability to add capacity by adding more machines that share the load. | https://banes-lab.com/json/records/lexicon/scale-out | https://banes-lab.com/records/lexicon/scale-out.md | 3225 | 7df8696e535e8951631a84adeafc3b270dcb39911bf21b54896f673a9cea30c0 |
| lexicon:targeted-improvement | capability | Targeted Improvement | The ability to direct optimization effort at the specific constraint that limits performance. | https://banes-lab.com/json/records/lexicon/targeted-improvement | https://banes-lab.com/records/lexicon/targeted-improvement.md | 3240 | c440abb2b3664b6a6234bf6e1a31042ad207ca77d402153fc47b2f9f0900885d |
| lexicon:traffic-distribution | capability | Traffic Distribution | The ability to spread incoming requests across multiple backends evenly. | https://banes-lab.com/json/records/lexicon/traffic-distribution | https://banes-lab.com/records/lexicon/traffic-distribution.md | 3269 | 175fe139f8196df7111269725e76a6919a5e2743ad10351e1908f161c8a44402 |
| lexicon:utilization-based-sizing | capability | Utilization-Based Sizing | The ability to size capacity from measured utilization and wait-time targets. | https://banes-lab.com/json/records/lexicon/utilization-based-sizing | https://banes-lab.com/records/lexicon/utilization-based-sizing.md | 3807 | 80b68b9b1d54e3db9c33714f2fb0de1620e68091b2326f5dbaa4be9c52c80b5e |
| lexicon:wait-time-prediction | capability | Wait-Time Prediction | The ability to predict how long work will wait given arrival and service rates. | https://banes-lab.com/json/records/lexicon/wait-time-prediction | https://banes-lab.com/records/lexicon/wait-time-prediction.md | 3266 | e7e8e2c87a607b4b3cc3b9ea3b61a900230057afa410d68fe076654262fe8dae |
| lexicon:always-fresh-reads | quality-attribute | Always-Fresh Reads | The degree to which every read returns the most recent write, which caching trades away for speed. | https://banes-lab.com/json/records/lexicon/always-fresh-reads | https://banes-lab.com/records/lexicon/always-fresh-reads.md | 4509 | e414dd74bfe2cba4b7cc1771c4c154ee414b990a94c1ff0e45445c4bc8adb828 |
| lexicon:cache-invalidation | activity | Cache Invalidation | The activity of removing or refreshing cached entries so stale data is not served. | https://banes-lab.com/json/records/lexicon/cache-invalidation | https://banes-lab.com/records/lexicon/cache-invalidation.md | 4569 | 404791ea08e2ecf87c6e2fce1bd73fec07ee7d0bd287d60aa999670209353f4e |
| lexicon:constant-factor-practicality | quality-attribute | Constant-Factor Practicality | The degree to which constant factors, ignored by asymptotic analysis, affect measured performance. | https://banes-lab.com/json/records/lexicon/constant-factor-practicality | https://banes-lab.com/records/lexicon/constant-factor-practicality.md | 4102 | 8daa81fc77a1077d5617189621f88511f27cd15364c44463d8d5babcc38288b8 |
| lexicon:cost-limit | quality-attribute | Cost/Limit | The degree to which a bigger single machine costs disproportionately more and eventually hits a hard limit. | https://banes-lab.com/json/records/lexicon/cost-limit | https://banes-lab.com/records/lexicon/cost-limit.md | 4009 | 1916e989839ac8848dc99c293527f3c0ebbf51e3d62a88dfa95e32d934e5de51 |
| lexicon:cpu-cost | quality-attribute | CPU Cost | The degree of processor time a technique consumes, often traded against memory savings. | https://banes-lab.com/json/records/lexicon/cpu-cost | https://banes-lab.com/records/lexicon/cpu-cost.md | 3946 | 15becb8bdb22296fcddff8e98df94b8e54da67dbdea5fb6f17b30dcd4ea343dc |
| lexicon:cross-shard-queries | quality-attribute | Cross-Shard Queries | The degree of difficulty and cost of a query that must gather data from multiple shards. | https://banes-lab.com/json/records/lexicon/cross-shard-queries | https://banes-lab.com/records/lexicon/cross-shard-queries.md | 3961 | 836742b8f8a6c15976ed53003b644c6ea2411f41734e5e3d18e2e4ba487fa04e |
| lexicon:distributed-complexity | quality-attribute | Distributed Complexity | The degree of intricacy introduced by spreading work across distributed nodes. | https://banes-lab.com/json/records/lexicon/distributed-complexity | https://banes-lab.com/records/lexicon/distributed-complexity.md | 4153 | c2e4467bb9a2bbe2fd7d5016c21931e08ce0107440acf52824e85ba51d71efdc |
| lexicon:distributed-coordination | quality-attribute | Distributed Coordination | The degree of coordination overhead required to keep distributed instances consistent. | https://banes-lab.com/json/records/lexicon/distributed-coordination | https://banes-lab.com/records/lexicon/distributed-coordination.md | 4149 | 63a7006b24f423b8ee6e56177a3a4a8f72b6d33fb9d49ec9a1f66c3e5f5a2753 |
| lexicon:environment-drift | quality-attribute | Environment Drift | The degree to which a test or runtime environment diverges from a reference over time, undermining comparability. | https://banes-lab.com/json/records/lexicon/environment-drift | https://banes-lab.com/records/lexicon/environment-drift.md | 4655 | 4067b988c46d059c772ea5ef252783c2c228ca76ba150cd092589df59dd2014b |
| lexicon:implementation-simplicity | quality-attribute | Implementation Simplicity | The degree to which code stays simple and clear, sometimes traded against maximal efficiency. | https://banes-lab.com/json/records/lexicon/implementation-simplicity | https://banes-lab.com/records/lexicon/implementation-simplicity.md | 4195 | 578b70fe4856831c84a0564b04124d1b4d40f6cb65609a9d72cac3dc2bb3c6d7 |
| lexicon:measurement-overhead | quality-attribute | Measurement Overhead | The degree of performance cost that the act of measuring imposes on the system being measured. | https://banes-lab.com/json/records/lexicon/measurement-overhead | https://banes-lab.com/records/lexicon/measurement-overhead.md | 4046 | 4f0d9e8f8901c25da576480106d5a01f60b691d551b77444d627438675c5e7a6 |
| lexicon:model-assumptions | constraint | Model Assumptions | The simplifying premises a performance model depends on, which limit how well it matches reality. | https://banes-lab.com/json/records/lexicon/model-assumptions | https://banes-lab.com/records/lexicon/model-assumptions.md | 4040 | 6aa160d96e879b4c831e1504010fc76844492e7646e59990420c3d44ed8155f3 |
| lexicon:over-provisioning | quality-attribute | Over-Provisioning | The degree to which allocated capacity exceeds demand, trading waste for safety margin. | https://banes-lab.com/json/records/lexicon/over-provisioning | https://banes-lab.com/records/lexicon/over-provisioning.md | 4137 | 7f30d4666038629d65c79aec8980ed1f9073c16ef69ac4cd3895fd73413bc462 |
| lexicon:read-your-writes-consistency | quality-attribute | Read-Your-Writes Consistency | The degree to which a client is guaranteed to see its own prior writes, which replica lag can break. | https://banes-lab.com/json/records/lexicon/read-your-writes-consistency | https://banes-lab.com/records/lexicon/read-your-writes-consistency.md | 4164 | ce10c84a72f6e80cbf54f66e7615ab91df47cf7f7d51014794fe65e46b7f4f36 |
| lexicon:readability-maintainability | quality-attribute | Readability/Maintainability | The degree to which code stays readable and maintainable, sometimes sacrificed for performance. | https://banes-lab.com/json/records/lexicon/readability-maintainability | https://banes-lab.com/records/lexicon/readability-maintainability.md | 4180 | 83379c88bd2264ee2dada9935554cc210d3bf4b5be9cac1c6c2967c433e38762 |
| lexicon:rebalancing-complexity | quality-attribute | Rebalancing Complexity | The degree of difficulty of redistributing data when partitions are added or removed. | https://banes-lab.com/json/records/lexicon/rebalancing-complexity | https://banes-lab.com/records/lexicon/rebalancing-complexity.md | 4090 | fc59ac9a5a769e5c2525e5fb0f926f8670cba6d14940541030e265b796e4aaa9 |
| lexicon:session-affinity | technique | Session Affinity | Routing all of a client's requests to the same server instance so its session state stays local. | https://banes-lab.com/json/records/lexicon/session-affinity | https://banes-lab.com/records/lexicon/session-affinity.md | 4054 | 71698a29e44003240b75e943f5b9559f3839c3e9b888b25033da44c10adfff13 |
| lexicon:state-access-latency | quality-attribute | State Access Latency | The degree of added latency incurred when state is fetched from an external store rather than held locally. | https://banes-lab.com/json/records/lexicon/state-access-latency | https://banes-lab.com/records/lexicon/state-access-latency.md | 4064 | c7db5804246b14afe174e4fd58bf2049f79c3ea6d551e3038d73ea7b925a4238 |
| lexicon:throughput-batching | quality-attribute | Throughput/Batching | The degree to which batching work raises throughput at the cost of per-item latency. | https://banes-lab.com/json/records/lexicon/throughput-batching | https://banes-lab.com/records/lexicon/throughput-batching.md | 3972 | 4e77fe4960b2920623da97ae3460ab3e6c211460b34283241b1f3f392ff353ac |
| lexicon:warm-up-latency | quality-attribute | Warm-Up Latency | The degree of delay before newly-added capacity becomes ready to serve traffic. | https://banes-lab.com/json/records/lexicon/warm-up-latency | https://banes-lab.com/records/lexicon/warm-up-latency.md | 3951 | 9ec8fc02f9f5bf095b7d12fc3e93e75a443a133d66e462b232538040663500f1 |
| lexicon:cache-contract | technique | Cache Contract | A technique for declaring what a cache entry is keyed by, how long it lives and what invalidates it. | https://banes-lab.com/json/records/lexicon/cache-contract | https://banes-lab.com/records/lexicon/cache-contract.md | 3157 | dfe313459c8b7a5502ab7c13fb2d974d7385e5280f89dcf04b6b85ccd61f9141 |
| lexicon:context-keyed-cache | technique | Context-Keyed Cache | A technique for including tenant, identity, version and every input that changes the result in a cache key. | https://banes-lab.com/json/records/lexicon/context-keyed-cache | https://banes-lab.com/records/lexicon/context-keyed-cache.md | 4086 | efcf022868c880e57fe8765089d80c5f39529492eccda24f0189c81e92c13aa9 |
| lexicon:cache-invalidation-on-write | technique | Cache Invalidation on Write | A technique for removing or refreshing cached entries in the same change that writes the data behind them. | https://banes-lab.com/json/records/lexicon/cache-invalidation-on-write | https://banes-lab.com/records/lexicon/cache-invalidation-on-write.md | 4477 | 06d854aebde1a83fa23e73676f3ecb04f23a633e85ee6c42a7f2230118217c3b |
| lexicon:batch-fetch | technique | Batch Fetch | A technique for loading the related data for many items in one query or call instead of one per item. | https://banes-lab.com/json/records/lexicon/batch-fetch | https://banes-lab.com/records/lexicon/batch-fetch.md | 3556 | edd9bc8b8531f0e67cab22997bf9c1859b0545b01df4af04d8d7c45bf778a4d8 |
| lexicon:externalize-session-state | technique | Externalize Session State | A technique for moving per-user or per-request state out of instance memory into a shared store. | https://banes-lab.com/json/records/lexicon/externalize-session-state | https://banes-lab.com/records/lexicon/externalize-session-state.md | 6140 | 0cd8bdb8cdc195139b93dd3f70a2a5dba3c693792dd2c4b92a5a89ae24093561 |
| lexicon:replace-algorithm | technique | Replace Algorithm | A technique for swapping an algorithm or data structure for one with better complexity for the inputs at hand. | https://banes-lab.com/json/records/lexicon/replace-algorithm | https://banes-lab.com/records/lexicon/replace-algorithm.md | 3998 | 75b428dc7016ea38cb210bd0344edcdadde299d4434bda558a9a3a6cbf053cc1 |
| lexicon:add-index | technique | Add Index | A technique for adding an index on the fields a slow query filters or sorts by. | https://banes-lab.com/json/records/lexicon/add-index | https://banes-lab.com/records/lexicon/add-index.md | 3905 | c1b69f329c7c38547d085e3618977fdcb5fe4f37180a80618944891dcf38cce2 |
| lexicon:chunked-processing | technique | Chunked Processing | A technique for processing large data in fixed-size pieces, so memory use stays bounded. | https://banes-lab.com/json/records/lexicon/chunked-processing | https://banes-lab.com/records/lexicon/chunked-processing.md | 3615 | e2fd8674c69100047cd6323a6c5939374ab6902d8c245b2bafe85ecc01e9451b |
| lexicon:repeated-stable-computation | anti-pattern | Repeated Stable Computation | A defect in which a costly computation or query whose result does not change is repeated on every request. | https://banes-lab.com/json/records/lexicon/repeated-stable-computation | https://banes-lab.com/records/lexicon/repeated-stable-computation.md | 3271 | 5b7f7744cf02499c2340afd51a952ff95be86857f1d867dbea771d2230e73ddb |
| lexicon:batch-only-processing | approach | Batch-Only Processing | Processing data in scheduled batches rather than as a continuous low-latency stream. | https://banes-lab.com/json/records/lexicon/batch-only-processing | https://banes-lab.com/records/lexicon/batch-only-processing.md | 4171 | f7cefc66f2853d764f1d09fdeeb70fcb9368443a9f80e1a3d84ab5a6fd9b7b70 |
| lexicon:ordering-state | quality-attribute | Ordering/State | The degree to which processing an unbounded stream complicates preserving event order and bounded state. | https://banes-lab.com/json/records/lexicon/ordering-state | https://banes-lab.com/records/lexicon/ordering-state.md | 4157 | 133971104d319c51768b917e1a13fb19d2a937ba965b32833a21c659cc1d8aa7 |
| lexicon:forward-only-state-model | constraint | Forward-Only State Model | The requirement that processing keep only forward-moving state, never needing to revisit earlier input. | https://banes-lab.com/json/records/lexicon/forward-only-state-model | https://banes-lab.com/records/lexicon/forward-only-state-model.md | 3312 | 2ccfe5335a5ac4f7bbfdbe522714485937c37024dc66cbffde1305a8cc5a85f0 |
| lexicon:global-optimization | quality-attribute | Global Optimization | The degree to which processing data in a single pass forgoes optimizations that need a full view of the data. | https://banes-lab.com/json/records/lexicon/global-optimization | https://banes-lab.com/records/lexicon/global-optimization.md | 4257 | d0bb4898dfb709bffd4774d3cf5da42c6317a89433aa6676a785b0713778d024 |
| lexicon:multi-pass-full-materialization | technique | Multi-Pass Full Materialization | Loading a full dataset into memory and traversing it in multiple passes, rather than in a single streaming pass. | https://banes-lab.com/json/records/lexicon/multi-pass-full-materialization | https://banes-lab.com/records/lexicon/multi-pass-full-materialization.md | 4315 | 46451b6d34946bfe0887a63d718f58e96af5ab5f9c7c36dbaf6b7518f9d1b640 |
| lexicon:error-propagation-debugging | quality-attribute | Error Propagation/Debugging | The degree to which splitting work into pipeline stages makes an error harder to trace back to its origin. | https://banes-lab.com/json/records/lexicon/error-propagation-debugging | https://banes-lab.com/records/lexicon/error-propagation-debugging.md | 4346 | 5afa1758795c8431987d8a61d735a65542b9edce47fc237e398022b56c15e33e |
| lexicon:monolithic-processing-function | anti-pattern | Monolithic Processing Function | One large function that performs every processing step at once, so stages cannot be tested or reused independently. | https://banes-lab.com/json/records/lexicon/monolithic-processing-function | https://banes-lab.com/records/lexicon/monolithic-processing-function.md | 3846 | 83f901bcb653182fca59dbf25e04fdac9f0b2b57f037ad4ef59ef07cc4233fa7 |
| lexicon:stage-contracts | constraint | Stage Contracts | The requirement that each pipeline stage declare a typed contract for what it consumes and produces. | https://banes-lab.com/json/records/lexicon/stage-contracts | https://banes-lab.com/records/lexicon/stage-contracts.md | 3368 | 0368b11f84a2f3b82261ae0c41a2bc67df64aa3b6b2ec8e9b037318fe975407d |
| lexicon:stepwise-transformation | capability | Stepwise Transformation | The ability to transform data through a sequence of small, composable stages. | https://banes-lab.com/json/records/lexicon/stepwise-transformation | https://banes-lab.com/records/lexicon/stepwise-transformation.md | 3231 | b896757754e55d1bcf4cb56c0cdb9c6b129a0a3fe0122da74c1622678e8a5da1 |
| lexicon:streaming | capability | Streaming | The ability to process data continuously as it arrives rather than in complete batches. | https://banes-lab.com/json/records/lexicon/streaming | https://banes-lab.com/records/lexicon/streaming.md | 3293 | 2ccc617dbf52e2fe32b6289b8c5119a07956534e81a71b70d1a5482592eff509 |
| lexicon:avoiding-unneeded-work | capability | Avoiding Unneeded Work | The ability to skip computing results that are never used. | https://banes-lab.com/json/records/lexicon/avoiding-unneeded-work | https://banes-lab.com/records/lexicon/avoiding-unneeded-work.md | 3258 | 2ef8d3b6a1ad37904493fef45a0f115f0b24457a473e9a82c332acde01e823a8 |
| lexicon:debuggability-resource-lifetime | quality-attribute | Debuggability/Resource Lifetime | The degree to which deferring computation makes execution order harder to debug and resource lifetimes harder to reason about. | https://banes-lab.com/json/records/lexicon/debuggability-resource-lifetime | https://banes-lab.com/records/lexicon/debuggability-resource-lifetime.md | 4287 | dc9d4ccd1b87f04e3383efecacfd302d7f11cd18e10e64554d22e654f562ca24 |
| lexicon:deferred-execution-semantics | constraint | Deferred Execution Semantics | The requirement that a computation's semantics defer its work until the result is demanded. | https://banes-lab.com/json/records/lexicon/deferred-execution-semantics | https://banes-lab.com/records/lexicon/deferred-execution-semantics.md | 3401 | a8279e0465f15497f849277deeff3f6452bcc6e7bab4a18125fa00dda967c731 |
| lexicon:eager-full-materialization | technique | Eager Full Materialization | Computing and materializing a complete result up front, rather than deferring computation until parts are needed. | https://banes-lab.com/json/records/lexicon/eager-full-materialization | https://banes-lab.com/records/lexicon/eager-full-materialization.md | 4216 | fa99d88cf01cfbebd897b8e32753c2a691dafa23fae6248c9c024438fee1ca4e |
| lexicon:large-data-processing | capability | Large Data Processing | The ability to process datasets larger than memory by reading them in order, a piece at a time. | https://banes-lab.com/json/records/lexicon/large-data-processing | https://banes-lab.com/records/lexicon/large-data-processing.md | 3321 | f6789eae9bb91c94805adde46d2fa3c79cfb21b485c35fb08c2241b2192d8cf4 |
| lexicon:lookup-performance | quality-attribute | Lookup Performance | The degree to which reading strictly in sequence makes locating a specific item by key slow. | https://banes-lab.com/json/records/lexicon/lookup-performance | https://banes-lab.com/records/lexicon/lookup-performance.md | 4101 | 471719ae7a1d8818fc916a8ce866713d8765cc3e09ed366c1318ce04bb62ac87 |
| lexicon:ordered-read-model | constraint | Ordered Read Model | The requirement that data be read in a fixed forward order rather than by arbitrary index. | https://banes-lab.com/json/records/lexicon/ordered-read-model | https://banes-lab.com/records/lexicon/ordered-read-model.md | 3300 | f0ef0610fc37bbd620aa3b09d670cdf7b77ff3631b62d26500b6837f8dcb52e8 |
| lexicon:random-access-requirement | constraint | Random Access Requirement | A need to read arbitrary items by position or key on demand rather than strictly in sequence. | https://banes-lab.com/json/records/lexicon/random-access-requirement | https://banes-lab.com/records/lexicon/random-access-requirement.md | 4163 | 48979e297e6f40c8710423c874118c960510e5a0f80bbaa84330603584d4684a |
| lexicon:backtracking-algorithm | technique | Backtracking Algorithm | A method that explores options and reverts to an earlier point when one fails, requiring the ability to look back. | https://banes-lab.com/json/records/lexicon/backtracking-algorithm | https://banes-lab.com/records/lexicon/backtracking-algorithm.md | 4281 | 91cc3de033368136ed17d16b30776533e826ca08aac1146f16baf4e92e2a5dbe |
| lexicon:complex-grammar-global-state | quality-attribute | Complex Grammar/Global State | The degree to which forbidding backtracking makes complex grammars or global-state logic hard to express. | https://banes-lab.com/json/records/lexicon/complex-grammar-global-state | https://banes-lab.com/records/lexicon/complex-grammar-global-state.md | 4264 | 40776e0055bf7cfa7d95646a19ccc2288f2bf7f70afad7dae38ce46813a2a263 |
| lexicon:streaming-parsers | capability | Streaming Parsers | The ability to parse input incrementally as it streams in, without buffering the whole document. | https://banes-lab.com/json/records/lexicon/streaming-parsers | https://banes-lab.com/records/lexicon/streaming-parsers.md | 3401 | 4b1a4550ec2fb56fe9d955dea20eab24dca8e4b897b48875105e01a61d1b7a35 |
| lexicon:control-flow-centric-monolith | anti-pattern | Control-Flow-Centric Monolith | A monolith driven by imperative control flow rather than data dependencies, so stages cannot run or scale independently. | https://banes-lab.com/json/records/lexicon/control-flow-centric-monolith | https://banes-lab.com/records/lexicon/control-flow-centric-monolith.md | 3350 | eb23b1f1722e4d728e5d9f6408f368f930b26fc513ac3c8c4748fe8873189d82 |
| lexicon:data-dependencies | constraint | Data Dependencies | The requirement that the data each stage needs from others be declared as explicit dependencies. | https://banes-lab.com/json/records/lexicon/data-dependencies | https://banes-lab.com/records/lexicon/data-dependencies.md | 3382 | 56c0f6edb0ffb0115b998f405fae88e4eb7529087946e0a1b8630a8c98812967 |
| lexicon:parallel-stream-processing | capability | Parallel/Stream Processing | The ability to run independent stages in parallel or stream data between them as it is produced. | https://banes-lab.com/json/records/lexicon/parallel-stream-processing | https://banes-lab.com/records/lexicon/parallel-stream-processing.md | 3257 | 98af9611fc9dd48d3a03773bdc5ea2fcec8dfc7b99d7a6bbde19003494acf7fd |
| lexicon:stages | constraint | Stages | The requirement that processing be decomposed into discrete stages connected by data flow. | https://banes-lab.com/json/records/lexicon/stages | https://banes-lab.com/records/lexicon/stages.md | 4277 | e84eec708c717ab78cf989193c6598aea0d92c03e71fe341a6d99277b300d6d5 |
| lexicon:state-coordination | quality-attribute | State Coordination | The degree to which a data-driven design must still coordinate shared state across concurrent stages. | https://banes-lab.com/json/records/lexicon/state-coordination | https://banes-lab.com/records/lexicon/state-coordination.md | 4060 | 33f0e42c5723dc2f05f8974e3ef82fd31e8cdaf3eb8a82c6421d5f8a0a192db0 |
| lexicon:no-hidden-state | constraint | No Hidden State | The requirement that a processor keep no state between invocations, so each call starts afresh from what it is given. | https://banes-lab.com/json/records/lexicon/no-hidden-state | https://banes-lab.com/records/lexicon/no-hidden-state.md | 3728 | aded5e019348111d6d78c7c6ff3ab195e133b2af691b153d9968d2a186a85893 |
| lexicon:parallel-processing | capability | Parallel Processing | The ability to process many records at once because each is handled independently of the others. | https://banes-lab.com/json/records/lexicon/parallel-processing | https://banes-lab.com/records/lexicon/parallel-processing.md | 3299 | f270dd22bedfa9cd1b20a6597cd36c2f2599b0fd9444f6ccdb190843920bade6 |
| lexicon:stateful-business-rules | quality-attribute | Stateful Business Rules | The degree to which rules that inherently depend on accumulated state resist a purely stateless design. | https://banes-lab.com/json/records/lexicon/stateful-business-rules | https://banes-lab.com/records/lexicon/stateful-business-rules.md | 4227 | 989d077991c5ce97ae691ea7b3f4cc975f255cfe600163b04a294c1d4d434272 |
| lexicon:stateful-hidden-accumulation | anti-pattern | Stateful Hidden Accumulation | Accumulating state inside a processor across records, so results depend on invisible history. | https://banes-lab.com/json/records/lexicon/stateful-hidden-accumulation | https://banes-lab.com/records/lexicon/stateful-hidden-accumulation.md | 3921 | 78d0e2d2135161bcae4791d074fde7a2c904e1b7d59841f070292f698597101f |
| lexicon:bounded-aggregation-over-unbounded-streams | capability | Bounded Aggregation over Unbounded Streams | The ability to aggregate an endless stream by grouping its events into bounded windows. | https://banes-lab.com/json/records/lexicon/bounded-aggregation-over-unbounded-streams | https://banes-lab.com/records/lexicon/bounded-aggregation-over-unbounded-streams.md | 3342 | 9a6bcd3573fbf97e433fbaafc4de56b47090575a8e6ea84128cda099204ea7cd |
| lexicon:bounded-state | quality-attribute | Bounded State | The degree to which processing keeps its working state within a fixed bound regardless of input size. | https://banes-lab.com/json/records/lexicon/bounded-state | https://banes-lab.com/records/lexicon/bounded-state.md | 3305 | c5e49380aef17c9f9a9ca7b017a21d936e10de8b4bb575e37084931a8293b27a |
| lexicon:event-time | artifact | Event Time | The time at which an event occurred, carried on the event and used to assign it to a window. | https://banes-lab.com/json/records/lexicon/event-time | https://banes-lab.com/records/lexicon/event-time.md | 3168 | 45656e08a45f10f5feb8c9344f5865d01e2f2a5301da4c259843be749ee89d0c |
| lexicon:late-data-handling | quality-attribute | Late-Data Handling | The degree to which windowing by event time must reckon with events that arrive after their window has closed. | https://banes-lab.com/json/records/lexicon/late-data-handling | https://banes-lab.com/records/lexicon/late-data-handling.md | 4004 | 4cb5704fa9687af700f501fcfa86985527b416191eb800e6f66dafddcc47f81c |
| lexicon:unbounded-accumulation | anti-pattern | Unbounded Accumulation | Aggregating an endless stream into ever-growing state that eventually exhausts memory. | https://banes-lab.com/json/records/lexicon/unbounded-accumulation | https://banes-lab.com/records/lexicon/unbounded-accumulation.md | 3675 | c0b8046fa692f926f1ce6e7c81465b9d7039fef823c226d471a7b4e5a5e87c5f |
| lexicon:parallel-branch-processing | capability | Parallel Branch Processing | The ability to process independent branches of work simultaneously across workers. | https://banes-lab.com/json/records/lexicon/parallel-branch-processing | https://banes-lab.com/records/lexicon/parallel-branch-processing.md | 3293 | 7bdb87b6664f6167370be9ae08fbbfce75b2cf0ff89346a410bfd33762267ee7 |
| lexicon:result-aggregation | capability | Result Aggregation | The ability to combine the outputs of parallel branches back into a single result. | https://banes-lab.com/json/records/lexicon/result-aggregation | https://banes-lab.com/records/lexicon/result-aggregation.md | 3848 | 8d163a28526c6f3473d2681e53124fdf8a7f5cdf5e2f7604a0e159a30a780cc7 |
| lexicon:serial-item-processing | approach | Serial Item Processing | Processing independent items one at a time in sequence, rather than in parallel. | https://banes-lab.com/json/records/lexicon/serial-item-processing | https://banes-lab.com/records/lexicon/serial-item-processing.md | 4076 | 428a5c91e68397408dcd22e233610d0b1a5e95dc9eed11d5817f743f8becdee1 |
| lexicon:fitness-for-purpose | quality-attribute | Fitness for Purpose | The degree to which the chosen processing model matches the latency and volume the problem needs. | https://banes-lab.com/json/records/lexicon/fitness-for-purpose | https://banes-lab.com/records/lexicon/fitness-for-purpose.md | 3340 | 77a8c3d13f88a817c46dbf78b7d88411271740fb6b447da8fdca427d2d29299b |
| lexicon:latency-requirement-clarity | constraint | Latency Requirement Clarity | The requirement that a workload's latency and freshness needs be made explicit before a processing model is chosen. | https://banes-lab.com/json/records/lexicon/latency-requirement-clarity | https://banes-lab.com/records/lexicon/latency-requirement-clarity.md | 3411 | c287c49470601aee8a7e02b5d42eba8e937442e7eaffc455f3536c8b6f40da8d |
| lexicon:latency-appropriate-processing-model | capability | Latency-Appropriate Processing Model | The ability to choose batch or stream processing to match a workload's latency needs. | https://banes-lab.com/json/records/lexicon/latency-appropriate-processing-model | https://banes-lab.com/records/lexicon/latency-appropriate-processing-model.md | 3416 | e3ae27b314f7c91080e85e6013bd19d060580a3ef154ab60147d1cf384ad4e70 |
| lexicon:one-size-fits-all-processing | anti-pattern | One-Size-Fits-All Processing | Forcing every workload through a single processing model regardless of its latency or volume needs. | https://banes-lab.com/json/records/lexicon/one-size-fits-all-processing | https://banes-lab.com/records/lexicon/one-size-fits-all-processing.md | 3847 | 7438633ca6ec78479607b2da820a809e20823fed3b89342d88ef4a2c5aa61134 |
| lexicon:operational-duplication | quality-attribute | Operational Duplication | The degree to which supporting both batch and streaming paths duplicates operational effort and code. | https://banes-lab.com/json/records/lexicon/operational-duplication | https://banes-lab.com/records/lexicon/operational-duplication.md | 4135 | 5d559071a98cbebc4aa3f9872483c721d877179e837e7aa2495efcdabb7ad058 |
| lexicon:fuse-passes | technique | Fuse Passes | A technique for combining several passes over the same data into one. | https://banes-lab.com/json/records/lexicon/fuse-passes | https://banes-lab.com/records/lexicon/fuse-passes.md | 3263 | 304ac6c4f4f1ef332c530d7829262fdce71f02904cc9e952f440d5de94d5c088 |
| lexicon:repeated-full-scan | anti-pattern | Repeated Full Scan | A defect in which large data is scanned or materialized several times where one pass would do. | https://banes-lab.com/json/records/lexicon/repeated-full-scan | https://banes-lab.com/records/lexicon/repeated-full-scan.md | 3303 | c4591bab5dda9387b6d43ed4cfa72d65aac29da7fd0ee8cc5608ab6eaf2c826f |
| lexicon:random-access-over-a-stream | anti-pattern | Random Access over a Stream | A defect in which code seeks or indexes into a source that can only be read in sequence. | https://banes-lab.com/json/records/lexicon/random-access-over-a-stream | https://banes-lab.com/records/lexicon/random-access-over-a-stream.md | 3303 | cebfbfc4f4a1dfc4078cc9d1b4a53f046051951968e420077c50c385e9b85aae |
| lexicon:look-back-buffering | anti-pattern | Look-Back Buffering | A defect in which a whole stream is buffered so that one stage can look back or ahead. | https://banes-lab.com/json/records/lexicon/look-back-buffering | https://banes-lab.com/records/lexicon/look-back-buffering.md | 3304 | 38dc8850d6946c6b7eb810461f2e147755994f902a44054c48709a836cdf3ee2 |
| lexicon:closed-core | anti-pattern | Closed Core | A core that cannot be extended without modifying its own source, so every addition edits the core. | https://banes-lab.com/json/records/lexicon/closed-core | https://banes-lab.com/records/lexicon/closed-core.md | 4508 | cff172b499871c4298fc9183ce84ecbcd08e2ab702799f7a828ed9d7f9e4e09e |
| lexicon:direct-control-ownership | anti-pattern | Direct Control Ownership | Application code driving the overall control flow itself instead of ceding it to a framework or container. | https://banes-lab.com/json/records/lexicon/direct-control-ownership | https://banes-lab.com/records/lexicon/direct-control-ownership.md | 3608 | 885be3898544fd472402f4ad44bace3378c515ddc153644f0fb7e66050c40276 |
| lexicon:direct-reference | anti-pattern | Direct Reference | Referring to a specific implementation directly instead of looking it up through a registry. | https://banes-lab.com/json/records/lexicon/direct-reference | https://banes-lab.com/records/lexicon/direct-reference.md | 3200 | d587c3c5511a8061f3e339dd57e368d5fa3b9e2a15e1ac6dcbd4f402ab423bf5 |
| lexicon:hardcoded-branch-constant | anti-pattern | Hardcoded Branch Constant | Controlling a feature with a hardcoded constant in the code instead of an externally-managed flag. | https://banes-lab.com/json/records/lexicon/hardcoded-branch-constant | https://banes-lab.com/records/lexicon/hardcoded-branch-constant.md | 3589 | 484be8d6c98ff44c180fd768bbdc5944219f96ff5ca10f4678d1c6cbb39e3e8f |
| lexicon:hardcoded-extensions | anti-pattern | Hardcoded Extensions | Wiring extensions directly into the core so adding one requires editing and rebuilding the core. | https://banes-lab.com/json/records/lexicon/hardcoded-extensions | https://banes-lab.com/records/lexicon/hardcoded-extensions.md | 3677 | a1c30a50a6ce16d53ba92268336e2301ae003f08d0f527edcafb3d645a299fe1 |
| lexicon:hardcoded-instantiation | anti-pattern | Hardcoded Instantiation | Creating dependencies with hardcoded constructors inside a class instead of injecting them. | https://banes-lab.com/json/records/lexicon/hardcoded-instantiation | https://banes-lab.com/records/lexicon/hardcoded-instantiation.md | 3634 | ae7cd7c7142eaa888785849950442e67c054cd6080dc25fa6fbe73e3841745d3 |
| lexicon:hardcoded-lookup | anti-pattern | Hardcoded Lookup | Hardcoding a service's address or instance instead of resolving it through a registry. | https://banes-lab.com/json/records/lexicon/hardcoded-lookup | https://banes-lab.com/records/lexicon/hardcoded-lookup.md | 3591 | f547abe30f7336ec164f35fa0c54738d388211d0706afc4a149f7f0ef2f85f0b |
| lexicon:continuous-delivery | capability | Continuous Delivery | The ability to release changes to production continuously through an automated pipeline. | https://banes-lab.com/json/records/lexicon/continuous-delivery | https://banes-lab.com/records/lexicon/continuous-delivery.md | 3174 | b6bf7a84df4058628fb6344c03879b9fb751f2b315bdb28f39bd324abb1c6d60 |
| lexicon:decoupled-deploy-and-release | capability | Decoupled Deploy and Release | The ability to deploy code and separately decide when to activate it for users. | https://banes-lab.com/json/records/lexicon/decoupled-deploy-and-release | https://banes-lab.com/records/lexicon/decoupled-deploy-and-release.md | 3143 | 3a1472b9818747a548080c5cbadf55fc0da1ba58e97cc1b123c6dadaabadb8a5 |
| lexicon:dynamic-lookup | capability | Dynamic Lookup | The ability to find a registered component by key at runtime. | https://banes-lab.com/json/records/lexicon/dynamic-lookup | https://banes-lab.com/records/lexicon/dynamic-lookup.md | 3144 | e3fe451a00a41f6f5022858931e349370e882592bfe1643149bd9ae2273afe87 |
| lexicon:dynamic-resolution | capability | Dynamic Resolution | The ability to resolve a service's current location or instance at runtime. | https://banes-lab.com/json/records/lexicon/dynamic-resolution | https://banes-lab.com/records/lexicon/dynamic-resolution.md | 3124 | 903009418af5a91003659210725643b1b67fe842ef1baeb441f3f5ad57ccd100 |
| lexicon:framework-control-flow | capability | Framework Control Flow | The ability to let a framework drive the overall control flow and call into application code. | https://banes-lab.com/json/records/lexicon/framework-control-flow | https://banes-lab.com/records/lexicon/framework-control-flow.md | 3163 | 193547f183fab0b8b2284779b0c8a95530e694af8d50841ed2b655adecdcfee4 |
| lexicon:gradual-rollout | capability | Gradual Rollout | The ability to enable a feature for a growing subset of users over time. | https://banes-lab.com/json/records/lexicon/gradual-rollout | https://banes-lab.com/records/lexicon/gradual-rollout.md | 3581 | ed36ee7d16b6399c9f4c76fdcfd5849ebfad6fe6e537229fb532ea8dc7ed306a |
| lexicon:late-resolution | capability | Late Resolution | The ability to defer resolving which implementation to use until the moment it is needed. | https://banes-lab.com/json/records/lexicon/late-resolution | https://banes-lab.com/records/lexicon/late-resolution.md | 3091 | abd70fe9c0279b19d9892c956ea31e9788d72e3c86c9988d0584d1fa82b1f8c4 |
| lexicon:mocking | capability | Mocking | The ability to substitute test doubles for real dependencies by injecting them. | https://banes-lab.com/json/records/lexicon/mocking | https://banes-lab.com/records/lexicon/mocking.md | 3069 | e8541a92f37c259ae1514599b3d1d26de0ace87aa6af6099bfa6b6f63dbfc88c |
| lexicon:runtime-lookup | capability | Runtime Lookup | The ability to look up a needed service by name at runtime. | https://banes-lab.com/json/records/lexicon/runtime-lookup | https://banes-lab.com/records/lexicon/runtime-lookup.md | 3090 | 820a5a0fc26b5de6a60d482777b983f28f395f9ed8e09722edcd8d9894dc575b |
| lexicon:third-party-extension | capability | Third-Party Extension | The ability for outside developers to extend the system through published extension points. | https://banes-lab.com/json/records/lexicon/third-party-extension | https://banes-lab.com/records/lexicon/third-party-extension.md | 3082 | 838ce4784660d1851184653c31305292a9a1b3e1e0d8d0b90166d54821d5231b |
| lexicon:registry | mechanism | Registry | A central store that maps keys to registered components for later lookup. | https://banes-lab.com/json/records/lexicon/registry | https://banes-lab.com/records/lexicon/registry.md | 4583 | 766f91c2ded7ecb44f5e0d1157d3ec9fd774aa1b730f71ad26a344eb00d0875b |
| lexicon:externalized-flag-state | constraint | Externalized Flag State | The requirement that feature-flag values live in external configuration, not hardcoded in the code. | https://banes-lab.com/json/records/lexicon/externalized-flag-state | https://banes-lab.com/records/lexicon/externalized-flag-state.md | 3109 | f4cd700c3ffb339290a84ebfb1cf2875c276ce7ebb4e8e33e62792e73f310e3d |
| lexicon:keyed-registration | constraint | Keyed Registration | The requirement that each component register under a unique key by which it can be retrieved. | https://banes-lab.com/json/records/lexicon/keyed-registration | https://banes-lab.com/records/lexicon/keyed-registration.md | 3183 | e516ea574a6681cad355d665b05ad5e160b8e75a6ee4f353b28d981d40e6561e |
| lexicon:registration-protocol | constraint | Registration Protocol | The requirement of a defined protocol by which services register and deregister themselves. | https://banes-lab.com/json/records/lexicon/registration-protocol | https://banes-lab.com/records/lexicon/registration-protocol.md | 3153 | b5ae358a4a4942b03155e56233bac258cee671d2ae5bd17fc173668b36957f47 |
| lexicon:api-surface-growth | quality-attribute | API Surface Growth | The degree to which adding extension points enlarges the public API that must be kept stable. | https://banes-lab.com/json/records/lexicon/api-surface-growth | https://banes-lab.com/records/lexicon/api-surface-growth.md | 3992 | 9a02988bc490c9cebc027bf1d7f1156888f26fb6fc2d5d1845a0972742bf0196 |
| lexicon:constructor-complexity | quality-attribute | Constructor Complexity | The degree to which injecting many dependencies through constructors makes them long and unwieldy. | https://banes-lab.com/json/records/lexicon/constructor-complexity | https://banes-lab.com/records/lexicon/constructor-complexity.md | 4053 | c413400957353926ea27e050ded962434b63d6076a6b5493654b8c6a09e41513 |
| lexicon:explicit-dependencies | quality-attribute | Explicit Dependencies | The degree to which a component's dependencies are visible in its signature rather than acquired through hidden lookups. | https://banes-lab.com/json/records/lexicon/explicit-dependencies | https://banes-lab.com/records/lexicon/explicit-dependencies.md | 5051 | 59d9ad686d6056e2b0cd1395f64e6fd398898bc8249d8724bbe5756b7d556827 |
| lexicon:flag-debt | quality-attribute | Flag Debt | The degree to which stale, unremoved feature flags accumulate and clutter the code over time. | https://banes-lab.com/json/records/lexicon/flag-debt | https://banes-lab.com/records/lexicon/flag-debt.md | 3841 | db1e11df321ad84b44018243e1cac2ab600ecb9c5ffb7fb6c0c12692766a29ac |
| lexicon:global-state | quality-attribute | Global State | The degree to which a global registry behaves as shared global state that any code can reach. | https://banes-lab.com/json/records/lexicon/global-state | https://banes-lab.com/records/lexicon/global-state.md | 3873 | 780e788037019b5b48f4e7782643797a12bab7bead7612cf117771a7ffd8cc59 |
| lexicon:registry-availability | quality-attribute | Registry Availability | The degree to which the whole system's operation depends on the service registry staying available. | https://banes-lab.com/json/records/lexicon/registry-availability | https://banes-lab.com/records/lexicon/registry-availability.md | 4000 | b7da054416dec9cb1a8106357fb8e3014705c8ab6154c60fb9dc246caafd9a72 |
| lexicon:ungoverned-global-registry | anti-pattern | Ungoverned Global Registry | A defect in which a global registry is changed from anywhere, with no owner, lifecycle or validation of its entries. | https://banes-lab.com/json/records/lexicon/ungoverned-global-registry | https://banes-lab.com/records/lexicon/ungoverned-global-registry.md | 3182 | de6c948c028823e3952e5aa73513cc94ae7efc77cc18bed41492843ba2715487 |
| lexicon:availability | quality-attribute | Availability | The proportion of time a system is operational and able to serve requests. | https://banes-lab.com/json/records/lexicon/availability | https://banes-lab.com/records/lexicon/availability.md | 14773 | 0d176c77b2e614d3a5d4489785e17a4a0733a4e1df0f3720398ddec476872b76 |
| lexicon:security | quality-attribute | Security | The degree to which a system protects its data and behavior from unauthorized access, misuse, or attack. | https://banes-lab.com/json/records/lexicon/security | https://banes-lab.com/records/lexicon/security.md | 12705 | ee00b904a65a05f6b9d53538129cea34dcc2a0036e24bc1f56ee418b49c98a5c |
| lexicon:simplicity | quality-attribute | Simplicity | The absence of unnecessary structure, keeping a system easy to understand and change. | https://banes-lab.com/json/records/lexicon/simplicity | https://banes-lab.com/records/lexicon/simplicity.md | 14470 | eb0efddc84c363318a26cdc636b70b20054cdea2a4a6219cc1e0129d69cb954b |
| lexicon:debuggability | quality-attribute | Debuggability | The ease with which a fault can be located and understood from a system's observable behavior. | https://banes-lab.com/json/records/lexicon/debuggability | https://banes-lab.com/records/lexicon/debuggability.md | 12024 | bfcbb8d1817fc179c44ef258a852e68988598a546de49adba13a277625d5d0aa |
| lexicon:maintainability | quality-attribute | Maintainability | The ease with which a system can be corrected, adapted, and extended over its lifetime. | https://banes-lab.com/json/records/lexicon/maintainability | https://banes-lab.com/records/lexicon/maintainability.md | 8625 | 4370db14132d70d1e2d450438adaaf33340752a914d5d58c3ef87f87b26c18ff |
| lexicon:complexity | quality-attribute | Complexity | The degree of interdependence and intricacy that makes a system harder to reason about and change. | https://banes-lab.com/json/records/lexicon/complexity | https://banes-lab.com/records/lexicon/complexity.md | 7590 | 148cec4cceebc0721813b303adbaf2c7dc481787c9faa31050226dd5adccbe34 |
| lexicon:fault-isolation | quality-attribute | Fault Isolation | The degree to which a failure in one component is contained and prevented from cascading to others. | https://banes-lab.com/json/records/lexicon/fault-isolation | https://banes-lab.com/records/lexicon/fault-isolation.md | 4954 | 80168584be272613751383c2c9822c9cfda28fb4bab5992304825f239b8359c1 |
| lexicon:architecture-compliance | quality-attribute | Architecture Compliance | The degree to which an implementation conforms to its intended architectural rules, boundaries, and constraints. | https://banes-lab.com/json/records/lexicon/architecture-compliance | https://banes-lab.com/records/lexicon/architecture-compliance.md | 4552 | ae40abe558f122e62bc987d91ac687601736cd0206a543f12f25cd043facda34 |
| lexicon:coordination-overhead | quality-attribute | Coordination Overhead | The additional cost incurred to synchronize and coordinate concurrent or distributed units of work. | https://banes-lab.com/json/records/lexicon/coordination-overhead | https://banes-lab.com/records/lexicon/coordination-overhead.md | 5317 | 965ec35192aa3e8bdc678d27053b3530605c26cd30997991277564765e4fb796 |
| lexicon:data-integrity | quality-attribute | Data Integrity | The accuracy, consistency, and validity of data maintained over its entire lifecycle. | https://banes-lab.com/json/records/lexicon/data-integrity | https://banes-lab.com/records/lexicon/data-integrity.md | 4524 | edbb91d75f415d48ad29f40219cdb35d97e4d8478e0c5a02fa448721a1ed868c |
| lexicon:discoverability | quality-attribute | Discoverability | The ease with which a system's components, capabilities, or endpoints can be found and understood. | https://banes-lab.com/json/records/lexicon/discoverability | https://banes-lab.com/records/lexicon/discoverability.md | 6719 | a4e05909759c2698ec8ed8eede9b7fe1c72272469df722fef903ee550565b2dc |
| lexicon:mapping-overhead | quality-attribute | Mapping Overhead | The additional cost of translating data or calls between two differing representations or models. | https://banes-lab.com/json/records/lexicon/mapping-overhead | https://banes-lab.com/records/lexicon/mapping-overhead.md | 5162 | 8601e42f653ec2ec8316338cbc1349adb3bd17714597cbf2c91e6558e2276cb8 |
| lexicon:operational-overhead | quality-attribute | Operational Overhead | The ongoing effort and resource cost of deploying, running, and maintaining a system in production. | https://banes-lab.com/json/records/lexicon/operational-overhead | https://banes-lab.com/records/lexicon/operational-overhead.md | 5451 | c8d068013bcb0a79b0158d308ac06aafbaed25f79bfbb97d0f44fdca34de1726 |
| lexicon:ordering | quality-attribute | Ordering | The guarantee that events or messages are processed in a well-defined, consistent sequence. | https://banes-lab.com/json/records/lexicon/ordering | https://banes-lab.com/records/lexicon/ordering.md | 5611 | f691089455b61d266d9ecd2a47895a9ab2b05fd9d93bffcec2c0020af2fd7d94 |
| lexicon:partial-availability | quality-attribute | Partial Availability | The condition in which a system continues serving a subset of its functions while some components are unavailable. | https://banes-lab.com/json/records/lexicon/partial-availability | https://banes-lab.com/records/lexicon/partial-availability.md | 3437 | 67fe7d829320c739504a59f174cfd75735049794199b54908c201cdf5ffa05e4 |