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

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

| ref | kind | title | summary | json | markdown | bytes | fingerprint |
| --- | --- | --- | --- | --- | --- | --- | --- |
| lexicon:split-one-test-per-subject | technique | Split One Test per Subject | A technique for dividing a test that covers several subjects into one test file per subject. | https://banes-lab.com/json/records/lexicon/split-one-test-per-subject | https://banes-lab.com/records/lexicon/split-one-test-per-subject.md | 3396 | 188d6f4b50f979986e33ccebd1cfc49fc8ba06c80538ca771198942163448b25 |
| lexicon:take-the-domain-noun-as-the-subject | technique | Take the Domain Noun as the Subject | A technique for replacing the generic subject with the domain noun the file's source names. | https://banes-lab.com/json/records/lexicon/take-the-domain-noun-as-the-subject | https://banes-lab.com/records/lexicon/take-the-domain-noun-as-the-subject.md | 3406 | 84b530d147a0a49ebc349caafe857de746d68b4ea0583ae3d8719436d868ef2d |
| lexicon:classify-before-the-first-write | technique | Classify Before the First Write | A technique for deciding a file's concern and subject before writing it, so it is created under its final name. | https://banes-lab.com/json/records/lexicon/classify-before-the-first-write | https://banes-lab.com/records/lexicon/classify-before-the-first-write.md | 3445 | df4f037ed8be9a668242f246355c7a9b634a7aa1f2a0d1258188c64aa3af2a3e |
| lexicon:move-the-order-into-the-registry | technique | Move the Order into the Registry | A technique for recording a sequence in a registry instead of in numeric filename prefixes. | https://banes-lab.com/json/records/lexicon/move-the-order-into-the-registry | https://banes-lab.com/records/lexicon/move-the-order-into-the-registry.md | 3304 | 4e91a237e8468ae8a826c421fb4542a405238e168c770d5d185d66e0e003c5f6 |
| lexicon:drop-the-prefix | technique | Drop the Prefix | A technique for removing a numeric order prefix from filenames once a registry holds the order. | https://banes-lab.com/json/records/lexicon/drop-the-prefix | https://banes-lab.com/records/lexicon/drop-the-prefix.md | 3345 | 37c2176dd87b63952241801a0efd476aa18a5d9c688fdc66811302807ed45c63 |
| lexicon:resolve-the-slot-against-its-source | technique | Resolve the Slot Against Its Source | A technique for checking a slot word against the source that allocates it instead of against a copied vocabulary. | https://banes-lab.com/json/records/lexicon/resolve-the-slot-against-its-source | https://banes-lab.com/records/lexicon/resolve-the-slot-against-its-source.md | 3293 | 9ca22f56446faa2703a16b8425d1cb8b362f4ed97ba05ff3aa81ee4e5fe64674 |
| lexicon:remove-the-copies | technique | Remove the Copies | A technique for deleting vocabulary entries that copy words another source already owns. | https://banes-lab.com/json/records/lexicon/remove-the-copies | https://banes-lab.com/records/lexicon/remove-the-copies.md | 3306 | 5b46200d1d91642b28b9381a96a8a8914dd46829c52f811fc64f3ed27cedc732 |
| lexicon:declare-the-dialect | technique | Declare the Dialect | A technique for binding a file extension to the case splitter its language uses. | https://banes-lab.com/json/records/lexicon/declare-the-dialect | https://banes-lab.com/records/lexicon/declare-the-dialect.md | 3206 | 040f3190a8936d39fb891e6c27abd3028fdb549cd214a5b876d1011fe9c1835e |
| lexicon:rename-to-the-case-s-word-run | technique | Rename to the Case's Word Run | A technique for renaming a dialect file so its case splitter yields the three declared slots. | https://banes-lab.com/json/records/lexicon/rename-to-the-case-s-word-run | https://banes-lab.com/records/lexicon/rename-to-the-case-s-word-run.md | 3309 | d26feb79045aa503b5573002401b1557309b376cc08a7c947c2277ef40cae0ab |
| lexicon:move-the-file-into-its-concern-folder | technique | Move the File into Its Concern Folder | A technique for moving a loose root file into the concern folder its tag names. | https://banes-lab.com/json/records/lexicon/move-the-file-into-its-concern-folder | https://banes-lab.com/records/lexicon/move-the-file-into-its-concern-folder.md | 3332 | dc444d76dc26bfd5ffc4205a384f7bee0152d0ec8f2218e979fb67d6d0bd91e7 |
| lexicon:vocabulary-bound-reading | anti-pattern | Vocabulary-Bound Reading | A defect in which a word is read by the vocabulary that declares it rather than by the slot it lands in. | https://banes-lab.com/json/records/lexicon/vocabulary-bound-reading | https://banes-lab.com/records/lexicon/vocabulary-bound-reading.md | 3372 | e336070205a437b36bc24279e812ce5338194a305b68aabf149048d64622d01c |
| lexicon:tag-folder-mismatch | anti-pattern | Tag-Folder Mismatch | A defect in which a file's concern tag differs from the label of its parent folder. | https://banes-lab.com/json/records/lexicon/tag-folder-mismatch | https://banes-lab.com/records/lexicon/tag-folder-mismatch.md | 3306 | 378f609426fe8dddcd0bd63ce9d0cc6046e6f8b498e3ed75a654bb6ee5a25592 |
| lexicon:depth-anchored-discovery | anti-pattern | Depth-Anchored Discovery | A defect in which discovery is anchored to a depth, so a grouped set falls out of the pattern. | https://banes-lab.com/json/records/lexicon/depth-anchored-discovery | https://banes-lab.com/records/lexicon/depth-anchored-discovery.md | 3282 | 100178c7c37a611939ed78cf3a9affb68b57bf7f5bbb0c63d5844564f6fe01b9 |
| lexicon:shape-inferred-jurisdiction | anti-pattern | Shape-Inferred Jurisdiction | A defect in which jurisdiction is inferred from folder shape instead of declared. | https://banes-lab.com/json/records/lexicon/shape-inferred-jurisdiction | https://banes-lab.com/records/lexicon/shape-inferred-jurisdiction.md | 3296 | 6440c467d334a16b94ec30bfddeb2a9668a074773a48387663bd22d36cd547b3 |
| lexicon:per-check-exemption-list | anti-pattern | Per-Check Exemption List | A defect in which each check keeps its own exemption list for the same upstream tree. | https://banes-lab.com/json/records/lexicon/per-check-exemption-list | https://banes-lab.com/records/lexicon/per-check-exemption-list.md | 3338 | 38596ec9963b3dc193d65ec73aeb9fb4233ef2e6f2668c3fa84ffad49514b26f |
| lexicon:spine-read-as-a-dependency-rule | anti-pattern | Spine Read as a Dependency Rule | A defect in which the layer spine is read as a dependency-direction rule rather than a classification tie-break. | https://banes-lab.com/json/records/lexicon/spine-read-as-a-dependency-rule | https://banes-lab.com/records/lexicon/spine-read-as-a-dependency-rule.md | 3323 | c58ab330f24480fbc3c1215869b3cc603d4bae40e60e2c0803eb0bae517e85be |
| lexicon:domain-dialect-role | anti-pattern | Domain-Dialect Role | A defect in which an agnostic role is restated in a local domain dialect. | https://banes-lab.com/json/records/lexicon/domain-dialect-role | https://banes-lab.com/records/lexicon/domain-dialect-role.md | 3296 | 2f8f0526db70f75410c8093f1571e476b325fe306384ccd33b953c005c573352 |
| lexicon:prose-only-vocabulary | anti-pattern | Prose-Only Vocabulary | A defect in which a vocabulary is kept in prose the gate cannot read. | https://banes-lab.com/json/records/lexicon/prose-only-vocabulary | https://banes-lab.com/records/lexicon/prose-only-vocabulary.md | 3220 | 1a77223f8a5090878b6fb0e629ad4a9c463b152b70b4e29a9edb4917273bbf9c |
| lexicon:shared-subject-test | anti-pattern | Shared-Subject Test | A defect in which one test file covers several subjects. | https://banes-lab.com/json/records/lexicon/shared-subject-test | https://banes-lab.com/records/lexicon/shared-subject-test.md | 3284 | 515591332865e96057f111060723c685e6ab85b2256b45b27cf7fd8f4d7cc85e |
| lexicon:generic-subject-over-a-domain-file | anti-pattern | Generic Subject over a Domain File | A defect in which a file carries the generic subject while its source names the domain it serves. | https://banes-lab.com/json/records/lexicon/generic-subject-over-a-domain-file | https://banes-lab.com/records/lexicon/generic-subject-over-a-domain-file.md | 3300 | 9ecac21281b1414007e93f14928288bd9b28123c6712fc9677293f65c1d2cecc |
| lexicon:provisional-name | anti-pattern | Provisional Name | A defect in which a file is written under a provisional name and its correct name is left for a later sweep. | https://banes-lab.com/json/records/lexicon/provisional-name | https://banes-lab.com/records/lexicon/provisional-name.md | 3299 | 64f177e2e0855883fec7393081e638fca8f15df03234d3685504554a8298c084 |
| lexicon:copied-slot-word | anti-pattern | Copied Slot Word | A defect in which each word a source owns is copied into the declared vocabulary, one entry per allocated identity or upstream key. | https://banes-lab.com/json/records/lexicon/copied-slot-word | https://banes-lab.com/records/lexicon/copied-slot-word.md | 3272 | 7412f562972391cc516bc2ffcb6062577f8757f4b8acac9fbd040b99d142fd49 |
| lexicon:per-language-vocabulary | anti-pattern | Per-Language Vocabulary | A defect in which a separate vocabulary is declared for each language instead of one set of slots read through each language's case. | https://banes-lab.com/json/records/lexicon/per-language-vocabulary | https://banes-lab.com/records/lexicon/per-language-vocabulary.md | 3201 | 976debeba2448c731e8c59faa5eaf2aca0f5fb89d801819ab81e1d85e27106bf |
| lexicon:loose-root-file | anti-pattern | Loose Root File | A defect in which a file sits at a governed root while it is neither the entry document nor an accumulator. | https://banes-lab.com/json/records/lexicon/loose-root-file | https://banes-lab.com/records/lexicon/loose-root-file.md | 3334 | a2a063d2d6881f65e348668b4be50c18613807a31509dd0adf7b7b725c736731 |
| lexicon:idempotency-key-or-deterministic-operation | constraint | Idempotency Key or Deterministic Operation | The requirement that an operation carry a deduplication key or be deterministic so repeating it is safe. | https://banes-lab.com/json/records/lexicon/idempotency-key-or-deterministic-operation | https://banes-lab.com/records/lexicon/idempotency-key-or-deterministic-operation.md | 3300 | 0a5796d29c7de3da809c65b0a1067ab43b66c3317d60253deb39e53147cfc133 |
| lexicon:non-repeatable-side-effects | anti-pattern | Non-Repeatable Side Effects | Side effects whose repetition changes the outcome, so retrying an operation double-applies them. | https://banes-lab.com/json/records/lexicon/non-repeatable-side-effects | https://banes-lab.com/records/lexicon/non-repeatable-side-effects.md | 3293 | 2150277b4f280c5873831d0affc26ac8ac79bdc5c181d06c782679a77259d33f |
| lexicon:safe-retries | capability | Safe Retries | The ability to retry an operation without fear of duplicating its effects. | https://banes-lab.com/json/records/lexicon/safe-retries | https://banes-lab.com/records/lexicon/safe-retries.md | 3144 | ee811fbaac061a91aa342a3c1d110038465276e3aee401d0482bf34a20215742 |
| lexicon:state-tracking | quality-attribute | State Tracking | The degree to which making operations idempotent requires tracking processed keys or prior state. | https://banes-lab.com/json/records/lexicon/state-tracking | https://banes-lab.com/records/lexicon/state-tracking.md | 3935 | 5251c38777d95cebabdf96702a7547899e453d10e1383a6dfc593f659750089e |
| lexicon:all-or-nothing-state-change | capability | All-or-Nothing State Change | The ability to apply a set of changes so that either all of them take effect or none do. | https://banes-lab.com/json/records/lexicon/all-or-nothing-state-change | https://banes-lab.com/records/lexicon/all-or-nothing-state-change.md | 3188 | cac3986cc34abff58186cbf17c37bfd1de35bf8f538341e6336a3fb81b70093e |
| lexicon:distributed-scalability | quality-attribute | Distributed Scalability | The degree to which enforcing atomic transactions across nodes limits how far a system can scale out. | https://banes-lab.com/json/records/lexicon/distributed-scalability | https://banes-lab.com/records/lexicon/distributed-scalability.md | 4010 | 55a3e2b8b2cbea01d007211fae4d8c05ed4faed6c5b9932cfcbf0eafed2fcc97 |
| lexicon:partial-commit | anti-pattern | Partial Commit | Committing only some of a multi-step change after a failure, leaving state half-updated and inconsistent. | https://banes-lab.com/json/records/lexicon/partial-commit | https://banes-lab.com/records/lexicon/partial-commit.md | 3912 | 145d23cc085fb780196e3e0177ca8fb57359d83659c8e5421e57a983a144dac4 |
| lexicon:base-eventual-consistency | model | BASE/Eventual Consistency | A consistency model favoring availability and soft state, letting replicas converge over time rather than staying strongly consistent. | https://banes-lab.com/json/records/lexicon/base-eventual-consistency | https://banes-lab.com/records/lexicon/base-eventual-consistency.md | 3984 | 90fe7f68555d50211d84e5ade62fe99dcb84479a22e6c0b937bcb1277281ca6d |
| lexicon:distributed-availability | quality-attribute | Distributed Availability | The degree to which insisting on strong transactional consistency reduces availability across a distributed system. | https://banes-lab.com/json/records/lexicon/distributed-availability | https://banes-lab.com/records/lexicon/distributed-availability.md | 3953 | 224dca1adf88cabb516d87126093a9bf69155271c48ad97cfbd59ec8ae77e82d |
| lexicon:durability | quality-attribute | Durability | The degree to which committed data survives crashes and is never lost once acknowledged. | https://banes-lab.com/json/records/lexicon/durability | https://banes-lab.com/records/lexicon/durability.md | 3193 | 2fca4e300d9cea11cbb16a262d0f6c55d8de37ca56690e5c568bacf18bb75e31 |
| lexicon:strong-transactional-guarantees | capability | Strong Transactional Guarantees | The ability to guarantee that a group of operations is atomic, consistent, isolated, and durable. | https://banes-lab.com/json/records/lexicon/strong-transactional-guarantees | https://banes-lab.com/records/lexicon/strong-transactional-guarantees.md | 3138 | 02edd651be18777f2d14027e71e5127040a1da989fb8dadde8b949268944106f |
| lexicon:consistency-rules | constraint | Consistency Rules | The requirement that the invariants a transaction must preserve be defined for its scope. | https://banes-lab.com/json/records/lexicon/consistency-rules | https://banes-lab.com/records/lexicon/consistency-rules.md | 3325 | 733d8b5f3f693738eccaebd44030a853cef1c908807765eadc4bd2ed03c75f2c |
| lexicon:hidden-distributed-transaction | anti-pattern | Hidden Distributed Transaction | A transaction that silently spans service boundaries, coupling systems that should commit independently. | https://banes-lab.com/json/records/lexicon/hidden-distributed-transaction | https://banes-lab.com/records/lexicon/hidden-distributed-transaction.md | 4657 | 37300973fe77b063ff27d8ff45257818034d587786349715afe8c9b622017d1f |
| lexicon:large-transaction-scope | quality-attribute | Large Transaction Scope | The degree to which widening a transaction to cover more work increases contention and failure surface. | https://banes-lab.com/json/records/lexicon/large-transaction-scope | https://banes-lab.com/records/lexicon/large-transaction-scope.md | 4162 | 472506bf2a35a4c287fb5327e43883abae20fb4dd4241cf18605be87278ae190 |
| lexicon:safe-state-mutation | capability | Safe State Mutation | The ability to mutate state within a bounded transaction so partial failures cannot corrupt it. | https://banes-lab.com/json/records/lexicon/safe-state-mutation | https://banes-lab.com/records/lexicon/safe-state-mutation.md | 3263 | f59e1e237e69012b8137319bbb0e4e8622285a0385fa6a6449abe8a326de694d |
| lexicon:coordinated-persistence | capability | Coordinated Persistence | The ability to commit a set of related changes together as one atomic unit of work. | https://banes-lab.com/json/records/lexicon/coordinated-persistence | https://banes-lab.com/records/lexicon/coordinated-persistence.md | 3237 | 2d6c2419687fef08436bf91aab75c228530ef0356edc26431a84f1e77e098099 |
| lexicon:repository-complexity | quality-attribute | Repository Complexity | The degree to which coordinating saves through a unit of work adds indirection to the persistence layer. | https://banes-lab.com/json/records/lexicon/repository-complexity | https://banes-lab.com/records/lexicon/repository-complexity.md | 4115 | d591d55a39a16fc22ad535805c835d5b01b7c3629c3bd2750a41294aecd54961 |
| lexicon:scattered-save-calls | anti-pattern | Scattered Save Calls | Persisting related changes through many independent save calls, so a mid-sequence failure leaves partial state. | https://banes-lab.com/json/records/lexicon/scattered-save-calls | https://banes-lab.com/records/lexicon/scattered-save-calls.md | 3752 | 094f167edfdbfae1847ab3b6645cbaf8d171819d13578d54c119879c153a24e1 |
| lexicon:inconsistent-replicas-models | anti-pattern | Inconsistent Replicas/Models | Replicas or models that disagree on the same data, so reads return conflicting answers. | https://banes-lab.com/json/records/lexicon/inconsistent-replicas-models | https://banes-lab.com/records/lexicon/inconsistent-replicas-models.md | 3188 | db99f5bf66f339d5c178a2048eb93f0c61a1ffb4e6c6052a1f4e57b5ee8a3336 |
| lexicon:reliable-state | capability | Reliable State | The ability to trust that stored state always satisfies its invariants. | https://banes-lab.com/json/records/lexicon/reliable-state | https://banes-lab.com/records/lexicon/reliable-state.md | 3174 | 3c29c1092569a673b825a746f8b7f4ba748b36ef790b1cf950bec2f65c64b089 |
| lexicon:dirty-reads-writes | anti-pattern | Dirty Reads/Writes | Reading or overwriting another transaction's uncommitted changes, so a rollback leaves corrupt data. | https://banes-lab.com/json/records/lexicon/dirty-reads-writes | https://banes-lab.com/records/lexicon/dirty-reads-writes.md | 3578 | eac1ba22e9a6b37be116958fe6d6dbefa163e3fd19b90bf4fba4f26b36fa6bcb |
| lexicon:safe-concurrent-operations | capability | Safe Concurrent Operations | The ability to run concurrent transactions without their intermediate states interfering. | https://banes-lab.com/json/records/lexicon/safe-concurrent-operations | https://banes-lab.com/records/lexicon/safe-concurrent-operations.md | 3200 | 2316a6dc2e801d2a74f2f71e921ce0cc83d71cd5e98f1260e712b2dc699177dc |
| lexicon:safe-parallel-mutation | capability | Safe Parallel Mutation | The ability to let multiple actors mutate shared state in parallel without corrupting it. | https://banes-lab.com/json/records/lexicon/safe-parallel-mutation | https://banes-lab.com/records/lexicon/safe-parallel-mutation.md | 3299 | 3ded4fb1532e16e33d7d065a58b80d0c12de949bd0dced65ba1b4f767206591a |
| lexicon:shared-state-identification | constraint | Shared State Identification | The requirement that all state shared between concurrent actors be identified before it is guarded. | https://banes-lab.com/json/records/lexicon/shared-state-identification | https://banes-lab.com/records/lexicon/shared-state-identification.md | 3250 | f1b6e2c221d2e1062d7e6b97ffdec1ab1d68648f22eb4c903b0f9a8cae845179 |
| lexicon:blind-overwrite | anti-pattern | Blind Overwrite | Writing over another actor's update without checking whether the data changed first, silently losing it. | https://banes-lab.com/json/records/lexicon/blind-overwrite | https://banes-lab.com/records/lexicon/blind-overwrite.md | 3690 | fe54588d2d6a06d153739e468fa563bb4f9228551de398aff43628558a93ced2 |
| lexicon:conflict-detection | capability | Conflict Detection | The ability to detect that data changed since it was read, so a conflicting write can be rejected. | https://banes-lab.com/json/records/lexicon/conflict-detection | https://banes-lab.com/records/lexicon/conflict-detection.md | 3177 | e0f5f7bc531cc30440ebfd48d010e1ad3715adf34837dbe5e009da5eebd099e9 |
| lexicon:retry-complexity | quality-attribute | Retry Complexity | The degree to which rejecting conflicting writes pushes retry-and-merge logic onto callers. | https://banes-lab.com/json/records/lexicon/retry-complexity | https://banes-lab.com/records/lexicon/retry-complexity.md | 3977 | 847e1c4b484ec512c434d0d8d52ea407c2be6da05d1ec0c12c039d067711d8f5 |
| lexicon:version-field | artifact | Version Field | A field on a record whose value changes on each write, used to detect concurrent modification. | https://banes-lab.com/json/records/lexicon/version-field | https://banes-lab.com/records/lexicon/version-field.md | 3147 | 12295a0501ae4c7b99b02b5f4fae92f7d11fc6ae8205d0843ab94b86b8045e2a |
| lexicon:lock-ownership | constraint | Lock Ownership | The requirement that a lock be exclusively held by one actor for the duration of a critical section. | https://banes-lab.com/json/records/lexicon/lock-ownership | https://banes-lab.com/records/lexicon/lock-ownership.md | 3179 | 5e4a3a33825ae44adfc79038e7474a0a8d079bb1070053e569e842bce837df93 |
| lexicon:lock-free-throughput | quality-attribute | Lock-Free Throughput | The degree to which a design sustains high throughput by coordinating concurrent access without holding locks. | https://banes-lab.com/json/records/lexicon/lock-free-throughput | https://banes-lab.com/records/lexicon/lock-free-throughput.md | 4594 | 97094e7bdc089d4113c8e7eae1dcec4b97f27f5517b0600f24e39227707a0752 |
| lexicon:strong-conflict-prevention | capability | Strong Conflict Prevention | The ability to prevent conflicting updates by locking data before it is modified. | https://banes-lab.com/json/records/lexicon/strong-conflict-prevention | https://banes-lab.com/records/lexicon/strong-conflict-prevention.md | 3202 | 2dacdfc1e87d9e99c05878a8afddc6c2348c656f7b6d5b3374c0fc876c6f35b5 |
| lexicon:data-sharing | quality-attribute | Data Sharing | The degree to which strictly isolating state limits components from directly sharing data. | https://banes-lab.com/json/records/lexicon/data-sharing | https://banes-lab.com/records/lexicon/data-sharing.md | 3970 | e27b0c150e0308804ebb1e88402b09cad144d125544613306d78918631c68787 |
| lexicon:effect-boundaries | constraint | Effect Boundaries | The requirement that side effects be confined to explicit boundaries rather than scattered through pure logic. | https://banes-lab.com/json/records/lexicon/effect-boundaries | https://banes-lab.com/records/lexicon/effect-boundaries.md | 3236 | dbf4c61b00c8979468037fe6114343d159cb593ff398a8021ec5e5f3b13d9c22 |
| lexicon:performance-optimization | quality-attribute | Performance Optimization | The degree to which pushing side effects to the edges can forgo in-place optimizations that mutate for speed. | https://banes-lab.com/json/records/lexicon/performance-optimization | https://banes-lab.com/records/lexicon/performance-optimization.md | 4179 | 6be8c1bba709b09f683f0c58539334224e0f067439a6cf7243e77afe112cec47 |
| lexicon:pure-core-imperative-shell | pattern | Pure Core / Imperative Shell | An arrangement that keeps decision logic pure and pushes all side effects to a thin outer shell. | https://banes-lab.com/json/records/lexicon/pure-core-imperative-shell | https://banes-lab.com/records/lexicon/pure-core-imperative-shell.md | 4266 | e4556e0a800a7971b86b88755ff14444404ce1cd31fce9ceacb63d334bd47b6a |
| lexicon:ad-hoc-lock-ordering | anti-pattern | Ad-Hoc Lock Ordering | Ordering lock acquisition by hand-reasoning rather than a proven scheme, inviting deadlock. | https://banes-lab.com/json/records/lexicon/ad-hoc-lock-ordering | https://banes-lab.com/records/lexicon/ad-hoc-lock-ordering.md | 3634 | 14925e0a892046af8c904f71c7eab21afe448c49a7a1d699c5a24e681ccab360 |
| lexicon:concurrency-correctness | quality-attribute | Concurrency Correctness | The degree to which concurrent flows produce correct results free of races and lost updates, for example because each unit's state is isolated. | https://banes-lab.com/json/records/lexicon/concurrency-correctness | https://banes-lab.com/records/lexicon/concurrency-correctness.md | 4682 | 723c4d1bb7fd2b7d7a82563ce55ae3b019c773821100946254e7cf5f5d16379c |
| lexicon:concurrent-flow-modeling | capability | Concurrent-Flow Modeling | The ability to model concurrent token flow explicitly so its behavior can be analyzed. | https://banes-lab.com/json/records/lexicon/concurrent-flow-modeling | https://banes-lab.com/records/lexicon/concurrent-flow-modeling.md | 3189 | 897ca90efe7a8414d09e191148e40ae621d6b710ac69934041f6eaa1f4f40c3b |
| lexicon:deadlock-freedom | quality-attribute | Deadlock Freedom | The degree to which a concurrent design is provably free of states where progress halts permanently, which acquiring several locks pessimistically puts at risk. | https://banes-lab.com/json/records/lexicon/deadlock-freedom | https://banes-lab.com/records/lexicon/deadlock-freedom.md | 5039 | 112d57eeadbf663539c739a1f262f09583f971b0c82bad8677e4e7c08453f389 |
| lexicon:modeling-overhead | quality-attribute | Modeling Overhead | The degree to which formally modeling concurrency as a net adds effort over writing the code directly. | https://banes-lab.com/json/records/lexicon/modeling-overhead | https://banes-lab.com/records/lexicon/modeling-overhead.md | 3952 | 571e2b82ddca18cad96839ac4b1f7fa037fbceb48f9d646ed71a989bdc9a4047 |
| lexicon:places-and-transitions | constraint | Places and Transitions | The requirement that a modeled system be expressed as places holding tokens and transitions that move them. | https://banes-lab.com/json/records/lexicon/places-and-transitions | https://banes-lab.com/records/lexicon/places-and-transitions.md | 3263 | 6321a76068e155d11fe60b6521dbe97d19afafa2fbd97a56afbc1a5f9c2323e8 |
| lexicon:reachability-and-deadlock-analysis | capability | Reachability and Deadlock Analysis | The ability to analyze which states a concurrent model can reach and whether any of them deadlock. | https://banes-lab.com/json/records/lexicon/reachability-and-deadlock-analysis | https://banes-lab.com/records/lexicon/reachability-and-deadlock-analysis.md | 3753 | 92958dbf13795849b1865c0b0bb7e79f3b47df6b4ec90cbc17a7a63510be9c7c |
| lexicon:reconciliation-job | technique | Reconciliation Job | A technique for periodically comparing two copies of related state and repairing the differences found. | https://banes-lab.com/json/records/lexicon/reconciliation-job | https://banes-lab.com/records/lexicon/reconciliation-job.md | 5335 | 26de32df24cfc33935fa07adfbe7a1d18025c9f7174958822c720999ce8da35b |
| lexicon:merge-policy | technique | Merge Policy | A technique for declaring how two concurrent changes to one value are combined. | https://banes-lab.com/json/records/lexicon/merge-policy | https://banes-lab.com/records/lexicon/merge-policy.md | 3078 | f9d3fe51c38ff409f23e1ca8e523bbf9d37bc19d60e82bbd42d2025494616dc7 |
| lexicon:transaction-isolation-level | technique | Transaction Isolation Level | A technique for choosing how much concurrent transactions see of each other's uncommitted and recent writes. | https://banes-lab.com/json/records/lexicon/transaction-isolation-level | https://banes-lab.com/records/lexicon/transaction-isolation-level.md | 3919 | 989f6fc861ea6344c822c02713930a189404b09680c94d27c2282023a6587899 |
| lexicon:make-immutable | technique | Make Immutable | A technique for replacing in-place mutation with new values, so state shared between readers cannot change under them. | https://banes-lab.com/json/records/lexicon/make-immutable | https://banes-lab.com/records/lexicon/make-immutable.md | 6261 | bd311463eb701a46e256e4854abe994394ac8b93601c5c1b349fb7f5c1d7e003 |
| lexicon:read-from-primary-after-write | technique | Read From Primary After Write | A technique for routing a client's reads to the primary for a short time after it writes, so it sees its own write. | https://banes-lab.com/json/records/lexicon/read-from-primary-after-write | https://banes-lab.com/records/lexicon/read-from-primary-after-write.md | 4119 | 00c1a5e0bbdb949b7956717a0068392fdcdcfc8181700a973a677def240b5b61 |
| lexicon:consistency-contract | technique | Consistency Contract | A technique for stating which reads may be stale, for how long, and how a client learns that its write is visible. | https://banes-lab.com/json/records/lexicon/consistency-contract | https://banes-lab.com/records/lexicon/consistency-contract.md | 4102 | 0d19a1024bf5456759e419d48759d2646c1edbf3ced521a58bd7c6548fcf699f |
| lexicon:fix-the-race | technique | Fix the Race | A technique for removing a race by ordering, locking or making the shared state immutable, instead of retrying the test. | https://banes-lab.com/json/records/lexicon/fix-the-race | https://banes-lab.com/records/lexicon/fix-the-race.md | 3184 | 06e63c96f0feb0ce67c667b913ea31f7074ae9492788deb9ee711f98002106cd |
| lexicon:apply-concurrency-control | technique | Apply Concurrency Control | A technique for coordinating concurrent writers with locks, versions or ownership, so no write is lost. | https://banes-lab.com/json/records/lexicon/apply-concurrency-control | https://banes-lab.com/records/lexicon/apply-concurrency-control.md | 5930 | 226316b9185f5cad22a17c021478e148deb10b7e9e83f5b96f2a1235d10027e3 |
| lexicon:introduce-transaction-boundary | technique | Introduce Transaction Boundary | A technique for declaring which writes commit or fail together. | https://banes-lab.com/json/records/lexicon/introduce-transaction-boundary | https://banes-lab.com/records/lexicon/introduce-transaction-boundary.md | 4606 | c655ee64569c926d0d3001aaa59c137fc4a7cce489bff8ce3b4caadea9ce5d9c |
| lexicon:metrics | mechanism | Metrics | Quantitative measurements a system emits about its state and behavior for monitoring and analysis. | https://banes-lab.com/json/records/lexicon/metrics | https://banes-lab.com/records/lexicon/metrics.md | 8450 | 4ab8a1586e4bb2022bb15e182a2bc9001701d0e847c5f05100b889886c3bd9ec |
| lexicon:contracts | constraint | Contracts | Explicit, enforceable agreements specifying the inputs, outputs, and guarantees between components. | https://banes-lab.com/json/records/lexicon/contracts | https://banes-lab.com/records/lexicon/contracts.md | 10121 | 7eaf16a4ad535649d1f705d8f5c4b8933d27a567841a28cca50d4618aabcdf39 |
| lexicon:independent-deployment | capability | Independent Deployment | The ability to release a component to production without coordinating the deployment of others. | https://banes-lab.com/json/records/lexicon/independent-deployment | https://banes-lab.com/records/lexicon/independent-deployment.md | 5514 | 714192d482e24d79c26372704ca381ed7195f7cc346c035a127cd0e9b0cb4142 |
| lexicon:delivery-speed | metric | Delivery Speed | The rate at which changes are delivered to production. | https://banes-lab.com/json/records/lexicon/delivery-speed | https://banes-lab.com/records/lexicon/delivery-speed.md | 7320 | b5b9a5cce0bd63e5e4b5b74f3a6c8c6ed0890f76841cc1e20c4924bb2961d62e |
| lexicon:boilerplate | quality-attribute | Boilerplate | Repetitive, mandatory scaffolding code that adds ceremony without domain value. | https://banes-lab.com/json/records/lexicon/boilerplate | https://banes-lab.com/records/lexicon/boilerplate.md | 6824 | 375d8717434c7418af5516617b7ce32cc11c7a589e691808000fda5f25318adf |
| lexicon:schema | artifact | Schema | A formal definition of the structure, types, and constraints of data. | https://banes-lab.com/json/records/lexicon/schema | https://banes-lab.com/records/lexicon/schema.md | 5724 | e67b1ad51c145253baee67dd330bc1e56ff1ebad33b8c579ca1218b4c2919aa1 |
| lexicon:compatibility | quality-attribute | Compatibility | The degree to which a component interoperates with other versions or systems without modification. | https://banes-lab.com/json/records/lexicon/compatibility | https://banes-lab.com/records/lexicon/compatibility.md | 4663 | 2327b87cce90830b47b7fb8e55bfc950be255e299a4cac9a3ef54ed739531ced |
| lexicon:cost | metric | Cost | The resource or financial expenditure required to build, run, or change a system. | https://banes-lab.com/json/records/lexicon/cost | https://banes-lab.com/records/lexicon/cost.md | 7475 | b7d384ba01142acd8c9724a472124d5d47a2413d1822730063cdbc00cfa6b565 |
| lexicon:metadata | artifact | Metadata | Descriptive data about a system's structure, capabilities, or content, consumed to drive behavior. | https://banes-lab.com/json/records/lexicon/metadata | https://banes-lab.com/records/lexicon/metadata.md | 4840 | 9aa5fe261fe06ee3225c8263923f415d4b268b5c4024d05ba6e93a8942bc2a24 |
| lexicon:discovery | capability | Discovery | The ability to locate available components, services, or capabilities at runtime. | https://banes-lab.com/json/records/lexicon/discovery | https://banes-lab.com/records/lexicon/discovery.md | 4797 | 59e30cb209732cb26e3266fe80bb9a4da2bc836b2780c3e35c261cac77a8362c |
| lexicon:iteration-speed | metric | Iteration Speed | The rate at which cycles of change and feedback can be completed. | https://banes-lab.com/json/records/lexicon/iteration-speed | https://banes-lab.com/records/lexicon/iteration-speed.md | 6539 | 7a01cddc62c8b93fe2cea33a911eee46bc24e2d826c899ea3c0ecd0dc35dfc05 |
| lexicon:race-conditions | anti-pattern | Race Conditions | A defect where the outcome depends on the uncontrolled interleaving of concurrent operations. | https://banes-lab.com/json/records/lexicon/race-conditions | https://banes-lab.com/records/lexicon/race-conditions.md | 6174 | 75ee283844191e59c77534490cf7546c2dadda5577181e9ba0aee9da095a30d4 |
| lexicon:operational-complexity | quality-attribute | Operational Complexity | The effort and intricacy required to deploy, run, and maintain a system in production. | https://banes-lab.com/json/records/lexicon/operational-complexity | https://banes-lab.com/records/lexicon/operational-complexity.md | 7189 | 93f5b9a221f027f0265a9df65bb9aca7ada3c6b2b3224e1cdf26bec0f83f4d34 |
| lexicon:standards | constraint | Standards | Agreed conventions and specifications that components conform to for interoperability and consistency. | https://banes-lab.com/json/records/lexicon/standards | https://banes-lab.com/records/lexicon/standards.md | 5361 | c6ece1ecf71378808cfa90c74ad9d5db58e7c6d48e2a71dd54e338260001ab1a |
| lexicon:single-point-of-failure | anti-pattern | Single Point of Failure | A component whose failure alone halts the entire system because it has no redundancy. | https://banes-lab.com/json/records/lexicon/single-point-of-failure | https://banes-lab.com/records/lexicon/single-point-of-failure.md | 4659 | a302c965d8fafe3c7e15cdb31d7785dda8ef7247796a52e960733b9aa2575b8f |
| lexicon:debugging | activity | Debugging | The activity of locating and diagnosing the cause of a defect. | https://banes-lab.com/json/records/lexicon/debugging | https://banes-lab.com/records/lexicon/debugging.md | 5735 | 0d898a5c8b927456dffec26fc48216331a995631bfc0eb735505aff74f400548 |
| lexicon:specification | artifact | Specification | A precise, authoritative description of required behavior, structure, or interface. | https://banes-lab.com/json/records/lexicon/specification | https://banes-lab.com/records/lexicon/specification.md | 4752 | bb14511ae62cb9b59da47a1cdeb223bcb9aaaccecb988a02f2e301fc86a799e0 |
| lexicon:false-positives | metric | False Positives | Incorrect positive results reported when the detected condition is not present. | https://banes-lab.com/json/records/lexicon/false-positives | https://banes-lab.com/records/lexicon/false-positives.md | 6530 | e1d46ea05d7f3309fe002e6488d3c9a2df4ad6e281b3410f38a8da600c6b1b05 |
| lexicon:ownership | constraint | Ownership | A clear assignment of responsibility for a component to a person or team. | https://banes-lab.com/json/records/lexicon/ownership | https://banes-lab.com/records/lexicon/ownership.md | 4768 | acad5d896c9eb8739dd98f249567ef06e47054de61eb4e16038d39b51baa6de0 |
| lexicon:silent-failure | anti-pattern | Silent Failure | A failure that occurs without surfacing any error, log, or signal, leaving it undetected. | https://banes-lab.com/json/records/lexicon/silent-failure | https://banes-lab.com/records/lexicon/silent-failure.md | 4981 | a047a9c15fb1f8f25dcf79868dc419877dbd5f02eb7f371fb16a126b08020b7a |
| lexicon:message-contract | constraint | Message Contract | The agreed schema and semantics of messages exchanged between components. | https://banes-lab.com/json/records/lexicon/message-contract | https://banes-lab.com/records/lexicon/message-contract.md | 4241 | a0fdbb9b2e96343b4be90be94e4f4e52d29f6bd72eb4a622a88579b1c3560aa0 |
| lexicon:replay | capability | Replay | The ability to re-process a recorded sequence of events to reconstruct or recover state, including the state at a past point. | https://banes-lab.com/json/records/lexicon/replay | https://banes-lab.com/records/lexicon/replay.md | 3797 | bbfa96d0c69990216cc98898ed1fac22ab3dfe5032958c8a07ec70c0ee16e703 |
| lexicon:dsls | technique | DSLs | Domain-specific languages, small notations tailored to express solutions within one problem domain. | https://banes-lab.com/json/records/lexicon/dsls | https://banes-lab.com/records/lexicon/dsls.md | 3997 | 3387939a7e13ebd74f86ad6b18a96acc86ef88f8f3af2f81b4912d13df8bc1ed |
| lexicon:acceptance-criteria | constraint | Acceptance Criteria | Predefined conditions a deliverable must satisfy to be accepted as complete and correct. | https://banes-lab.com/json/records/lexicon/acceptance-criteria | https://banes-lab.com/records/lexicon/acceptance-criteria.md | 3846 | e01d0b5abf41b6483845da27d130af872d36282bc789af072e5ee4870480dcbb |
| lexicon:ambiguous-naming | anti-pattern | Ambiguous Naming | Identifiers whose meaning is unclear or open to multiple interpretations, obscuring intent. | https://banes-lab.com/json/records/lexicon/ambiguous-naming | https://banes-lab.com/records/lexicon/ambiguous-naming.md | 4884 | 019a8244a44426ea2a0ae366f8a2f83fe9d1469b53afe0b902a4990d1fd87e71 |
| lexicon:automated-enforcement | mechanism | Automated Enforcement | Machine-applied checking that rules and policies hold, catching violations without manual review. | https://banes-lab.com/json/records/lexicon/automated-enforcement | https://banes-lab.com/records/lexicon/automated-enforcement.md | 6852 | 0038e14b3f33f3f98d8987facd4430ee9adc7eada116097f5d43b40109e91b1b |
| lexicon:automation | capability | Automation | The execution of tasks by software or machinery without manual intervention. | https://banes-lab.com/json/records/lexicon/automation | https://banes-lab.com/records/lexicon/automation.md | 4246 | d3fadf5aba892736900cabdfc5256df1822e282f387d5968c8d6646bed65f9e5 |
| lexicon:boolean-flag-soup | anti-pattern | Boolean Flag Soup | Representing state through many interdependent boolean flags, producing tangled and invalid combinations. | https://banes-lab.com/json/records/lexicon/boolean-flag-soup | https://banes-lab.com/records/lexicon/boolean-flag-soup.md | 4186 | 22d821ee6ec65ef0b3b9c2dcdc3606c7fb4394c9bcd8b8ef83d4758228c5ed46 |
| lexicon:capacity-planning | activity | Capacity Planning | Forecasting resource demand and provisioning capacity to meet it without waste or shortfall. | https://banes-lab.com/json/records/lexicon/capacity-planning | https://banes-lab.com/records/lexicon/capacity-planning.md | 3998 | bd8e01cecde95d88187c482d6525e81d8f055d968b225c7769575697e60a118f |
| lexicon:code-generation | technique | Code Generation | Producing source code automatically from a higher-level model, schema, or specification. | https://banes-lab.com/json/records/lexicon/code-generation | https://banes-lab.com/records/lexicon/code-generation.md | 6539 | b7dca0e8d14d458061e9c2efa0ba337f7ce77119baa92395acffb97c50a7f348 |
| lexicon:composition-root | pattern | Composition Root | The single startup location where an application's object graph is assembled and its dependencies wired. | https://banes-lab.com/json/records/lexicon/composition-root | https://banes-lab.com/records/lexicon/composition-root.md | 4695 | fa1a34ffbddb9e36a49e36ae85393e898ecf97d70bd08f81bd03666ab4333c35 |
| lexicon:context | artifact | Context | The surrounding information and circumstances captured to make a decision, event, or log entry interpretable. | https://banes-lab.com/json/records/lexicon/context | https://banes-lab.com/records/lexicon/context.md | 4131 | 0942bb93b76906153bc886c7e8d34844c66b4458cffb02b4402199787322d03a |
| lexicon:continuous-processing | approach | Continuous Processing | Handling data incrementally as it arrives, rather than in discrete scheduled batches. | https://banes-lab.com/json/records/lexicon/continuous-processing | https://banes-lab.com/records/lexicon/continuous-processing.md | 4037 | 4eb79e55c680eb3b26089c0c5214e91ffa0f51b4abace62ac7f37c865e1feb98 |
| lexicon:controlled-access | capability | Controlled Access | Mediated, restricted access to a resource so that only permitted operations reach it. | https://banes-lab.com/json/records/lexicon/controlled-access | https://banes-lab.com/records/lexicon/controlled-access.md | 4026 | 5af5cb705f9d68835b5256eca635e6133f62dcc6b4fe1cbe1380838338e9df8d |
| lexicon:controlled-evolution | capability | Controlled Evolution | The managed, deliberate change of a system over time without breaking existing consumers. | https://banes-lab.com/json/records/lexicon/controlled-evolution | https://banes-lab.com/records/lexicon/controlled-evolution.md | 4011 | 531af9c31cb16ddbe0a068c2c411ecbcc872fd8a3ae2a37b6fb8bdaceb52250d |
| lexicon:cross-cutting-concerns | constraint | Cross-Cutting Concerns | Concerns such as logging, security, or transactions whose implementation spans many modules rather than localizing to one. | https://banes-lab.com/json/records/lexicon/cross-cutting-concerns | https://banes-lab.com/records/lexicon/cross-cutting-concerns.md | 5660 | 72de14b6f5e6491d996a40801b4fbe8e628546014fd151df84e5da0d39274988 |
| lexicon:damage-limitation | capability | Damage Limitation | Containing the blast radius of a failure or breach so its impact stays bounded. | https://banes-lab.com/json/records/lexicon/damage-limitation | https://banes-lab.com/records/lexicon/damage-limitation.md | 3999 | 9888d57ebff42d0c9ffe85ebdd8023c024f787a1b39f8431df96b40bbedeb70d |
| lexicon:evaluation | activity | Evaluation | The systematic assessment of a model or system's behavior and quality against defined criteria. | https://banes-lab.com/json/records/lexicon/evaluation | https://banes-lab.com/records/lexicon/evaluation.md | 3303 | 61a66a6da946e7bf18148da2a61c878ab75718bd632b9964f053df942e43a5a3 |
| lexicon:evidence | artifact | Evidence | Recorded proof that substantiates a claim, decision, or compliance requirement. | https://banes-lab.com/json/records/lexicon/evidence | https://banes-lab.com/records/lexicon/evidence.md | 3962 | bb701667bf1e32d50d0caa67547d34d35cb78625c5e25ce4e1e36f3e9ffe2c1e |
| lexicon:explicit-inputs | constraint | Explicit Inputs | All data a computation needs supplied through its parameters rather than read from ambient or hidden state. | https://banes-lab.com/json/records/lexicon/explicit-inputs | https://banes-lab.com/records/lexicon/explicit-inputs.md | 3973 | 0c90b2c49cb7f0652deb249e2dca70631c0fd1c730afb5cabea849f078c7089d |
| lexicon:fallback | mechanism | Fallback | An alternative path or default invoked automatically when the primary operation fails or is unavailable. | https://banes-lab.com/json/records/lexicon/fallback | https://banes-lab.com/records/lexicon/fallback.md | 4378 | 2f2b5d8d0314a755a5f4f9f0ac3c65ff80fb925401f3630615eb835dae045974 |
| lexicon:independent-work-units | constraint | Independent Work Units | Work partitioned into discrete units that execute in isolation, without shared mutable state or ordering dependencies. | https://banes-lab.com/json/records/lexicon/independent-work-units | https://banes-lab.com/records/lexicon/independent-work-units.md | 4027 | a0df5efffb492380a46e96c00212a684c6a59f19f3ac3fdb7f4b7a1a8f3d2467 |
| lexicon:large-input-handling | capability | Large Input Handling | The ability to process inputs too large to fit in memory, through streaming or chunking. | https://banes-lab.com/json/records/lexicon/large-input-handling | https://banes-lab.com/records/lexicon/large-input-handling.md | 4168 | 05da7a54600db3b9088527042c629cc467f283dbe4f4a64c1364259e7d4ca6f8 |
| lexicon:legal-transition-enforcement | mechanism | Legal-Transition Enforcement | Rejecting any state change that is not a permitted transition. | https://banes-lab.com/json/records/lexicon/legal-transition-enforcement | https://banes-lab.com/records/lexicon/legal-transition-enforcement.md | 3382 | f0a779859f57e13b7ad7f305b66ef6f7219c2ab5ca0c1e13e1c7c240fd70d48a |
| lexicon:plugins | mechanism | Plugins | Independently-developed components that attach to a host at defined extension points to add capabilities. | https://banes-lab.com/json/records/lexicon/plugins | https://banes-lab.com/records/lexicon/plugins.md | 4510 | 29e62d36f3d3ff0291d4e753f418e4b6bca9a6eb2158f90d7a9556cfb0390c74 |
| lexicon:policy | constraint | Policy | A declared set of rules governing what actions are permitted or denied within a system. | https://banes-lab.com/json/records/lexicon/policy | https://banes-lab.com/records/lexicon/policy.md | 5513 | 69197a04151993c8e691950b6389feb75e08b510afc65a7dc987d43abf7a4959 |
| lexicon:recovery | capability | Recovery | Restoring a system to correct operation or a consistent state after a failure. | https://banes-lab.com/json/records/lexicon/recovery | https://banes-lab.com/records/lexicon/recovery.md | 4209 | ffde3617c32de4ebfc34e989fcd83a965c6d8030afc2bfe9fb06169456dc84c0 |
| lexicon:reuse | capability | Reuse | Using an existing component, module, or solution in a new context rather than rebuilding it. | https://banes-lab.com/json/records/lexicon/reuse | https://banes-lab.com/records/lexicon/reuse.md | 4070 | 06d1f37ba86b9e6d3ec05a50c9e4889bfcaa732dfeca7769e364f17d21e1645e |
| lexicon:runtime-indirection | mechanism | Runtime Indirection | Resolving a binding or call target at runtime through an intermediary layer rather than a direct, static reference. | https://banes-lab.com/json/records/lexicon/runtime-indirection | https://banes-lab.com/records/lexicon/runtime-indirection.md | 5203 | 913e2fa16bf1874a9d5c542bcdbdbdf3788da131644c243cd26eeb9309d82de6 |
| lexicon:safe-defaults | principle | Safe Defaults | Choosing default configurations and behaviors that are safe when left unchanged. | https://banes-lab.com/json/records/lexicon/safe-defaults | https://banes-lab.com/records/lexicon/safe-defaults.md | 3937 | 3c3c0466a20a9d9a1767daf2438aba13ed75c9fec1758c42efb6f2f61d226830 |
| lexicon:safe-refactoring | capability | Safe Refactoring | Changing a system's internal structure with confidence that its observable behavior is preserved. | https://banes-lab.com/json/records/lexicon/safe-refactoring | https://banes-lab.com/records/lexicon/safe-refactoring.md | 3961 | 92c2f27221d5d46f0a00f9d03fdd029c78be346ea0d419a245926bfc35307bbf |
| lexicon:safe-substitution | capability | Safe Substitution | Replacing a component or expression with an equivalent one without altering program correctness. | https://banes-lab.com/json/records/lexicon/safe-substitution | https://banes-lab.com/records/lexicon/safe-substitution.md | 4027 | c67c6fb6ad24879b512029a938aba6f393a722fbea0f7b6935629aadf938298a |
| lexicon:model-drift | anti-pattern | Model Drift | The gradual loss of a model's fidelity to the reality it represents, as data or conditions change over time. | https://banes-lab.com/json/records/lexicon/model-drift | https://banes-lab.com/records/lexicon/model-drift.md | 3491 | 04d4e68d6cb9b4bf5b49399e9949541c1c64743df9bb7eaaa931ac575fd02af6 |
| lexicon:stable-contracts | constraint | Stable Contracts | Interfaces and agreements that remain unchanged over time so that consumers can depend on them safely. | https://banes-lab.com/json/records/lexicon/stable-contracts | https://banes-lab.com/records/lexicon/stable-contracts.md | 4385 | 4ae88e6977679902cd82a71ee56a2bd8bbd4a3cf5b4e1229db2e0df61bcf2c8c |
| lexicon:thresholds | constraint | Thresholds | Configured boundary values that trigger an alert or action when a measured metric crosses them. | https://banes-lab.com/json/records/lexicon/thresholds | https://banes-lab.com/records/lexicon/thresholds.md | 3374 | 432245500206eb0c898c31c4fb862082cd98f96249a833eaf795eb35462f395b |
| lexicon:time-budget | constraint | Time Budget | A bounded maximum amount of time allotted for an operation to complete. | https://banes-lab.com/json/records/lexicon/time-budget | https://banes-lab.com/records/lexicon/time-budget.md | 3809 | ced3517cca59089c8d304c985b22390c58836c39fbefd96613380c167bb1e66b |
| lexicon:time-cost | metric | Time Cost | The amount of time an activity requires, weighed as a cost against its benefit. | https://banes-lab.com/json/records/lexicon/time-cost | https://banes-lab.com/records/lexicon/time-cost.md | 4526 | 2c5df7c9a64b7f0fe54a77f14ef792b2764d9527b47fc282bda9653f879e4af6 |
| lexicon:type-metadata | artifact | Type Metadata | Descriptive data about the types of a structure's fields, available for inspection at runtime. | https://banes-lab.com/json/records/lexicon/type-metadata | https://banes-lab.com/records/lexicon/type-metadata.md | 4496 | d2b679c834af521cbea314290b72e76ab616fb6e45382da51955464f57cee69f |
| lexicon:undo-redo | capability | Undo/Redo | The ability to reverse a previously applied operation and to reapply it. | https://banes-lab.com/json/records/lexicon/undo-redo | https://banes-lab.com/records/lexicon/undo-redo.md | 3312 | 550ab1a6a6f70f51916f290d4bde2fe4ce0243832fa893e658f67ce7f2fc46dc |
| lexicon:name-the-concept | technique | Name the Concept | A technique for giving a recurring group of values or steps a name in the domain language and one home in the code. | https://banes-lab.com/json/records/lexicon/name-the-concept | https://banes-lab.com/records/lexicon/name-the-concept.md | 8647 | 8b2c29089d916dd1db06bd4c72a98e7769e2b2160813828c18ed807c9caced75 |
| lexicon:name-constant | technique | Name Constant | A technique for replacing an unexplained literal with a named constant that states its meaning. | https://banes-lab.com/json/records/lexicon/name-constant | https://banes-lab.com/records/lexicon/name-constant.md | 2999 | ea781d6fb226a977f2861ea379aa2c13fc15ad05ced8d7c2434467e217a1b9ac |
| lexicon:replace-boolean-with-enum | technique | Replace Boolean with Enum | A technique for replacing a boolean parameter or flag with a closed set of named values. | https://banes-lab.com/json/records/lexicon/replace-boolean-with-enum | https://banes-lab.com/records/lexicon/replace-boolean-with-enum.md | 4402 | 38ea8aa00a28b84c9dd5e1983e44650720e380c4b3bfd7fd3398676209986045 |