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

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

| ref | kind | title | summary | json | markdown | bytes | fingerprint |
| --- | --- | --- | --- | --- | --- | --- | --- |
| lexicon:performance | quality-attribute | Performance | The speed, throughput, and resource efficiency with which a system performs its work. | https://banes-lab.com/json/records/lexicon/performance | https://banes-lab.com/records/lexicon/performance.md | 4866 | 5eae0b87f72255def6a8809e5aed69a8ba9d7f21adc8bf20986b69f3fe7edcea |
| lexicon:policy-complexity | quality-attribute | Policy Complexity | The difficulty of understanding, maintaining, and reasoning about a policy as its rules multiply. | https://banes-lab.com/json/records/lexicon/policy-complexity | https://banes-lab.com/records/lexicon/policy-complexity.md | 4841 | 4657ba4a8d361f98ef8e19aabb0e7f27fa2cbeafcdf625ed40ffc3532eced254 |
| lexicon:readability | quality-attribute | Readability | The ease with which source code can be read and understood by a developer. | https://banes-lab.com/json/records/lexicon/readability | https://banes-lab.com/records/lexicon/readability.md | 4860 | fb05d3ecc19e104e18bb80972825c0160abca06e38b792a1b04cb3251a7945eb |
| lexicon:reliability | quality-attribute | Reliability | The degree to which a system performs its required functions correctly and consistently over time. | https://banes-lab.com/json/records/lexicon/reliability | https://banes-lab.com/records/lexicon/reliability.md | 4032 | 8bf25547601b3bb51f1bcff1b8cc11baf0c72fdd33f25bd86a009b339f4e6f45 |
| lexicon:resource-efficiency | quality-attribute | Resource Efficiency | The degree to which a system accomplishes its work using minimal computational resources. | https://banes-lab.com/json/records/lexicon/resource-efficiency | https://banes-lab.com/records/lexicon/resource-efficiency.md | 3537 | 9bbe7d86fcd93665ab7c730d883afab493f44947356c330385e437fe92c6501d |
| lexicon:retry-safety | quality-attribute | Retry Safety | The property that an operation can be retried without producing duplicate or inconsistent effects. | https://banes-lab.com/json/records/lexicon/retry-safety | https://banes-lab.com/records/lexicon/retry-safety.md | 4116 | 21815be39427c57045cec878578249a85e9fb7ae8e65b8a0bc330ab4c2e51662 |
| lexicon:robustness | quality-attribute | Robustness | The degree to which a system continues to operate correctly under invalid input, stress, or unexpected conditions. | https://banes-lab.com/json/records/lexicon/robustness | https://banes-lab.com/records/lexicon/robustness.md | 5687 | 8844fb297fce43525d92061f186982b2ee093ee6ae77c727fc6c7e5581d729eb |
| lexicon:static-safety | quality-attribute | Static Safety | The guarantee that whole classes of errors are caught at compile time, before code runs. | https://banes-lab.com/json/records/lexicon/static-safety | https://banes-lab.com/records/lexicon/static-safety.md | 5847 | aba3b873cd707512f244abaaf4192fd0499246ac14bb8557ce3de352c2f6a0bb |
| lexicon:substitutability | quality-attribute | Substitutability | The degree to which a component can be replaced by another honoring the same contract without breaking clients. | https://banes-lab.com/json/records/lexicon/substitutability | https://banes-lab.com/records/lexicon/substitutability.md | 3953 | 4ee43b6686827a3c4f8f2f566fd1b847d57f2107d1c0ff0c851c3736e3317e4b |
| lexicon:team-autonomy | quality-attribute | Team Autonomy | The degree to which a team can make and deliver decisions independently, without cross-team coordination. | https://banes-lab.com/json/records/lexicon/team-autonomy | https://banes-lab.com/records/lexicon/team-autonomy.md | 5424 | 1169d33c851dd089de6f1228d2e35eccfaf75730d3124da2d507d8ce22f4cc61 |
| lexicon:tooling-complexity | quality-attribute | Tooling Complexity | The effort required to set up, learn, and maintain the tools a technique or approach depends on. | https://banes-lab.com/json/records/lexicon/tooling-complexity | https://banes-lab.com/records/lexicon/tooling-complexity.md | 5208 | 8b90191e9d22cfcfe80a85d939aee61102fb1e7a355b81484262de446bf41b1d |
| lexicon:user-experience | quality-attribute | User Experience | The overall quality of a user's interaction with a system, including responsiveness, clarity, and ease of use. | https://banes-lab.com/json/records/lexicon/user-experience | https://banes-lab.com/records/lexicon/user-experience.md | 5635 | 41561ceea8e33ffc31958779504b334d148dc3b2b55c01dd215228e71650729d |
| lexicon:health-signal | artifact | Health Signal | A machine-readable signal that reports whether a component is currently healthy, or that a fault or anomaly in it has been detected. | https://banes-lab.com/json/records/lexicon/health-signal | https://banes-lab.com/records/lexicon/health-signal.md | 3366 | bb0bd5df3227cfb9db6074a6cf81476341d4abeca3468c5c6a4e774e3b335f6a |
| lexicon:reduced-mean-time-to-recovery | capability | Reduced Mean Time to Recovery | The ability to shorten the mean time to recover from a failure by acting automatically. | https://banes-lab.com/json/records/lexicon/reduced-mean-time-to-recovery | https://banes-lab.com/records/lexicon/reduced-mean-time-to-recovery.md | 3822 | b1cef6f3e1f308adf8c49e373dd979a69131dd301c2482d81377884a209fad0a |
| lexicon:blind-routing | anti-pattern | Blind Routing | Routing traffic to instances without checking their health, so requests hit dead or degraded nodes. | https://banes-lab.com/json/records/lexicon/blind-routing | https://banes-lab.com/records/lexicon/blind-routing.md | 3767 | d8c6b112c5e48c412e4a90fd8f427dc2ed07c5dee1ec8f0c6aa3f32c602aac26 |
| lexicon:observable-health-criteria | constraint | Observable Health Criteria | The requirement that explicit, observable criteria define when a component counts as healthy. | https://banes-lab.com/json/records/lexicon/observable-health-criteria | https://banes-lab.com/records/lexicon/observable-health-criteria.md | 3315 | d1a75c84d6599a99500609388d71c19039c40e5046b9a735359ed2d01c10bd78 |
| lexicon:readiness-liveness-routing | capability | Readiness/Liveness Routing | The ability to route traffic only to instances that report themselves ready and alive. | https://banes-lab.com/json/records/lexicon/readiness-liveness-routing | https://banes-lab.com/records/lexicon/readiness-liveness-routing.md | 3367 | c85b2b6f337791a580e3240db81235e6795df7f6cf28c1bc4c43013b58e5ba46 |
| lexicon:continuity-during-failure | capability | Continuity During Failure | The ability to keep serving requests by switching to a standby when the primary fails. | https://banes-lab.com/json/records/lexicon/continuity-during-failure | https://banes-lab.com/records/lexicon/continuity-during-failure.md | 3293 | 7d058ed60067e39cc9f881ad96906a6c2e7c0650d10e38ddea13af7bae8e7f6b |
| lexicon:health-detection | capability | Health Detection | The ability to detect that a component has failed so a switchover can be triggered. | https://banes-lab.com/json/records/lexicon/health-detection | https://banes-lab.com/records/lexicon/health-detection.md | 3300 | 42540bc5f733c1ece231a953d9d9e225503b922dccad134d78ddb1b8804aa482 |
| lexicon:single-instance-dependency | anti-pattern | Single Instance Dependency | Depending on a single instance with no standby, so its failure takes down the whole service. | https://banes-lab.com/json/records/lexicon/single-instance-dependency | https://banes-lab.com/records/lexicon/single-instance-dependency.md | 3732 | 1443ab096db3e729aee194cd9c87690c4932e8cbf645901bc3c414a2a8e4adc0 |
| lexicon:replication-or-alternate-capacity | constraint | Replication or Alternate Capacity | The requirement that duplicate copies or spare capacity exist to take over when a component fails. | https://banes-lab.com/json/records/lexicon/replication-or-alternate-capacity | https://banes-lab.com/records/lexicon/replication-or-alternate-capacity.md | 3343 | 0c6b5baba6a07986345a091d35899e984a01b3cb98872cb07d8b2a3216bb6e26 |
| lexicon:consistency-lag | quality-attribute | Consistency Lag | The degree to which replicas trail the primary, so reads served from them may return stale data. | https://banes-lab.com/json/records/lexicon/consistency-lag | https://banes-lab.com/records/lexicon/consistency-lag.md | 4098 | c0d649adeb7e02b5e197442c6d238c8be302dc578b052c3cf996f98c9e4ada1b |
| lexicon:consistency-policy | constraint | Consistency Policy | The requirement that a defined policy specify how and when replicas converge to a consistent state. | https://banes-lab.com/json/records/lexicon/consistency-policy | https://banes-lab.com/records/lexicon/consistency-policy.md | 3219 | 2dc4b13c24c9c85a6fed7b6a0b3a698f65686ecdd3cd3a139b37d198771c4dea |
| lexicon:read-scaling | capability | Read Scaling | The ability to serve more read traffic by distributing it across replicas. | https://banes-lab.com/json/records/lexicon/read-scaling | https://banes-lab.com/records/lexicon/read-scaling.md | 3209 | 3b0a24e98c0bc9cd28ff27d8671b01f16dbd8f486279ffec0926a822a74370e0 |
| lexicon:single-copy-state | anti-pattern | Single Copy State | Keeping only one copy of state, so its loss or unavailability takes down the whole system. | https://banes-lab.com/json/records/lexicon/single-copy-state | https://banes-lab.com/records/lexicon/single-copy-state.md | 3614 | 7775fef7709395c6b28d37290b0ff363c84a324d55a13ce0beaf4cb53be7ddda |
| lexicon:cost-cold-start | quality-attribute | Cost/Cold Start | The degree to which scaling capacity up and down incurs added cost and cold-start latency. | https://banes-lab.com/json/records/lexicon/cost-cold-start | https://banes-lab.com/records/lexicon/cost-cold-start.md | 4002 | a6205519f4daf814d5f97e9abc17da645592d413a1bf5bcbfa53a5d569491fa7 |
| lexicon:fixed-capacity | approach | Fixed Capacity | Provisioning a fixed, preset amount of capacity, rather than adapting it to demand. | https://banes-lab.com/json/records/lexicon/fixed-capacity | https://banes-lab.com/records/lexicon/fixed-capacity.md | 4007 | e831b1f6adb797c9fd4ecc6914706a717952cb5096be0be1d1d3a798b5845ada |
| lexicon:horizontal-scalability | quality-attribute | Horizontal Scalability | The degree to which a system can grow by adding more interchangeable instances rather than enlarging one. | https://banes-lab.com/json/records/lexicon/horizontal-scalability | https://banes-lab.com/records/lexicon/horizontal-scalability.md | 3278 | 4046bd5b24645b8d7d56906afa86575613adcbd7abf159669b51e02b4fbc829d |
| lexicon:incident-reduction | capability | Incident Reduction | The ability to reduce the number of incidents that reach human responders by fixing them automatically. | https://banes-lab.com/json/records/lexicon/incident-reduction | https://banes-lab.com/records/lexicon/incident-reduction.md | 3312 | 8a5f6862913a71f36cdf00fdde4a9c8beab58c03704cd12bff461183c058562e |
| lexicon:manual-remediation | approach | Manual Remediation | Recovering from incidents through human-operated fixes, rather than automated remediation. | https://banes-lab.com/json/records/lexicon/manual-remediation | https://banes-lab.com/records/lexicon/manual-remediation.md | 4095 | a623a62bb0f0a66b3bc6a9f106e8a18e2dde7a6c0c7640dd26fae363ab0651f9 |
| lexicon:remediation-workflow | activity | Remediation Workflow | A defined corrective action, or sequence of steps, carried out to return a system to a healthy state after a fault is detected. | https://banes-lab.com/json/records/lexicon/remediation-workflow | https://banes-lab.com/records/lexicon/remediation-workflow.md | 3346 | e98bf353422168f61c114ee81ec63cbcc4d37df0d5b1807c086295007f279cd7 |
| lexicon:unsafe-automation | quality-attribute | Unsafe Automation | The degree to which automated remediation may take wrong or harmful corrective actions, for example on a faulty signal, faster than the developer can intervene. | https://banes-lab.com/json/records/lexicon/unsafe-automation | https://banes-lab.com/records/lexicon/unsafe-automation.md | 5169 | aa66b0ab311e56632b6f7319b44f04e35a0fc8b7c614841b36ee9349ff33aa44 |
| lexicon:data-migration-compatibility | quality-attribute | Data Migration Compatibility | The degree to which reverting code is constrained by forward data migrations that cannot easily be undone. | https://banes-lab.com/json/records/lexicon/data-migration-compatibility | https://banes-lab.com/records/lexicon/data-migration-compatibility.md | 4130 | 05ab04fbf2fb0377336b673fa91bcb9cd1ac22aa3c40e9e73a9875f86261a056 |
| lexicon:fast-failure-recovery | capability | Fast Failure Recovery | The ability to recover quickly from a bad release by reverting to the last good version. | https://banes-lab.com/json/records/lexicon/fast-failure-recovery | https://banes-lab.com/records/lexicon/fast-failure-recovery.md | 3324 | ed00b429de0022d2bad71565a6c310327ef9e6dff0cbadfd854a9abae7ec00b1 |
| lexicon:irreversible-deployment | anti-pattern | Irreversible Deployment | Deploying in a way that cannot be undone, so a bad release cannot be rolled back. | https://banes-lab.com/json/records/lexicon/irreversible-deployment | https://banes-lab.com/records/lexicon/irreversible-deployment.md | 3674 | 2c3f86b25ae3b9fa7631d9fb172ecf70e179aea1121ee88a58f086a62485f2ea |
| lexicon:reversible-deployment | constraint | Reversible Deployment | The requirement that a deployment be structured so it can be safely reverted to a prior version. | https://banes-lab.com/json/records/lexicon/reversible-deployment | https://banes-lab.com/records/lexicon/reversible-deployment.md | 3283 | 0281605fd078805882244940f2be9dc1dd3538676a8cb67a51c2e720a760b808 |
| lexicon:versioned-artifact | artifact | Versioned Artifact | A build artifact tagged with a distinct version so a prior one can be redeployed. | https://banes-lab.com/json/records/lexicon/versioned-artifact | https://banes-lab.com/records/lexicon/versioned-artifact.md | 3264 | 609bb029225278f2d4a7cba56f54e45202c8f420a7327212dba9b5e325ccc13b |
| lexicon:in-place-mutation-only | anti-pattern | In-Place Mutation Only | Upgrading by mutating the running environment in place, with no parallel target to cut over to or fall back from. | https://banes-lab.com/json/records/lexicon/in-place-mutation-only | https://banes-lab.com/records/lexicon/in-place-mutation-only.md | 3807 | eec9570964fb632ac9710f7b0a25939f6d1384ba1422a67ba60253d5eda6923a |
| lexicon:infrastructure-cost | quality-attribute | Infrastructure Cost | The degree to which running two full parallel environments doubles infrastructure cost during a cutover. | https://banes-lab.com/json/records/lexicon/infrastructure-cost | https://banes-lab.com/records/lexicon/infrastructure-cost.md | 4177 | eebabbf2732062107f65262c1ca640979396d217aa386dcd65796aa61ef50264 |
| lexicon:low-risk-cutover | capability | Low-Risk Cutover | The ability to switch traffic to a new version with low risk by keeping the old one ready to fall back to. | https://banes-lab.com/json/records/lexicon/low-risk-cutover | https://banes-lab.com/records/lexicon/low-risk-cutover.md | 3332 | 3900abfe4f684392f8d81425ca5c66fa020d67db18eb199c10bd2d970aef6123 |
| lexicon:parallel-environments | constraint | Parallel Environments | The requirement that two full production-equivalent environments run side by side for cutover. | https://banes-lab.com/json/records/lexicon/parallel-environments | https://banes-lab.com/records/lexicon/parallel-environments.md | 3316 | 525022093d10f4846ee77d385781b05a14b06f5b21a0ea3037e524e0dd71443a |
| lexicon:controlled-exposure | capability | Controlled Exposure | The ability to expose a new version to a small, controlled fraction of traffic first. | https://banes-lab.com/json/records/lexicon/controlled-exposure | https://banes-lab.com/records/lexicon/controlled-exposure.md | 3308 | 0832a95cc83fba0463dcfe5a177c4270cf5abdb65731b87057f8662e7c2d6737 |
| lexicon:progressive-delivery | approach | Progressive Delivery | A release strategy that rolls out changes gradually to widening audiences while monitoring for regressions. | https://banes-lab.com/json/records/lexicon/progressive-delivery | https://banes-lab.com/records/lexicon/progressive-delivery.md | 3315 | a026ffe513cbad6796f093780df5dcdcc2bddb558aada9b3973e35074fd97195 |
| lexicon:rollout-complexity | quality-attribute | Rollout Complexity | The degree to which staging a release in gradual increments adds orchestration complexity. | https://banes-lab.com/json/records/lexicon/rollout-complexity | https://banes-lab.com/records/lexicon/rollout-complexity.md | 4109 | db49da2cd12019d2dc2792e2a011c34485ff1f10518d18f7a989c039bf727988 |
| lexicon:traffic-splitting | mechanism | Traffic Splitting | A facility that routes a configurable proportion of traffic to different versions of a service. | https://banes-lab.com/json/records/lexicon/traffic-splitting | https://banes-lab.com/records/lexicon/traffic-splitting.md | 3360 | 0661e31f298e1f20aab640f33ac31fcf1316ae32a8cc90f2204e73e105e53e8e |
| lexicon:empirical-resilience-verification | capability | Empirical Resilience Verification | The ability to verify a system's resilience empirically by injecting faults and observing recovery. | https://banes-lab.com/json/records/lexicon/empirical-resilience-verification | https://banes-lab.com/records/lexicon/empirical-resilience-verification.md | 3333 | 12e747a34b7fec19fdb387827fc8fc0866a8733b67b654d3ff0b793b2e60aabe |
| lexicon:production-risk | quality-attribute | Production Risk | The degree to which deliberately injecting faults in production risks causing user-facing incidents. | https://banes-lab.com/json/records/lexicon/production-risk | https://banes-lab.com/records/lexicon/production-risk.md | 4212 | 5ecd48678836d4131466d7da973e304dcf814ca3b8fb4892b560b9396d011ff8 |
| lexicon:untested-failure-assumptions | anti-pattern | Untested Failure Assumptions | Assuming a system will survive failures without ever testing those assumptions against injected faults. | https://banes-lab.com/json/records/lexicon/untested-failure-assumptions | https://banes-lab.com/records/lexicon/untested-failure-assumptions.md | 3761 | 2069fd55eb212febfaabcf7ae813338329e93b8d0f3d26bf0c64225ad72dac28 |
| lexicon:connection-cleanup | capability | Connection Cleanup | The ability to close open connections cleanly when a process shuts down. | https://banes-lab.com/json/records/lexicon/connection-cleanup | https://banes-lab.com/records/lexicon/connection-cleanup.md | 3863 | c79efc0fea0d60c9f82cc970b0281e2faaced03ba0c7196a6f9eec87fbab779e |
| lexicon:hard-process-kill | anti-pattern | Hard Process Kill | Terminating a process abruptly without draining work, dropping in-flight requests and risking corrupt state. | https://banes-lab.com/json/records/lexicon/hard-process-kill | https://banes-lab.com/records/lexicon/hard-process-kill.md | 3747 | c8355560726ac6a3b394759206649b23c54ca79d442bd15ee3d622347d0c4cdf |
| lexicon:in-flight-work-drain | capability | In-Flight Work Drain | The ability to finish or safely hand off in-progress work before a process exits. | https://banes-lab.com/json/records/lexicon/in-flight-work-drain | https://banes-lab.com/records/lexicon/in-flight-work-drain.md | 3273 | 50f6e902d770aabfba6069000ea26801138ef90325564600ac1bc85204652b41 |
| lexicon:lifecycle-signals | constraint | Lifecycle Signals | The requirement that a process receive lifecycle signals telling it when to start draining and stop. | https://banes-lab.com/json/records/lexicon/lifecycle-signals | https://banes-lab.com/records/lexicon/lifecycle-signals.md | 3291 | 0d1de37b265be36c4c22fa10f9e2d49b0bd7b4694a464c7f0e6a9d1843a21a48 |
| lexicon:shutdown-latency | quality-attribute | Shutdown Latency | The degree to which draining in-flight work before exit lengthens the time a shutdown takes. | https://banes-lab.com/json/records/lexicon/shutdown-latency | https://banes-lab.com/records/lexicon/shutdown-latency.md | 4098 | a3134c568507baa83f0814b590c871b2bb207aa1bc9431c7e001d2a436189e99 |
| lexicon:disk-failure-survival | capability | Disk-Failure Survival | The ability to keep serving data after one or more disks fail, by reconstructing from redundancy. | https://banes-lab.com/json/records/lexicon/disk-failure-survival | https://banes-lab.com/records/lexicon/disk-failure-survival.md | 3308 | 8f3d762a0232e83df260da559b42b967fac7fa192bf364f80c7c9c4b45dbd9dc |
| lexicon:multiple-physical-disks | constraint | Multiple Physical Disks | The requirement that data span several physical disks so redundancy can survive a single-disk loss. | https://banes-lab.com/json/records/lexicon/multiple-physical-disks | https://banes-lab.com/records/lexicon/multiple-physical-disks.md | 3334 | e78a6a0d07b1ac522af09b4c69d6b9b6ebde7647903f47a0cd69b8dd9cf4b8b5 |
| lexicon:parity-based-recovery | capability | Parity-Based Recovery | The ability to reconstruct lost data from parity information stored across the disk array. | https://banes-lab.com/json/records/lexicon/parity-based-recovery | https://banes-lab.com/records/lexicon/parity-based-recovery.md | 3913 | 51a925621d53d3600436b75e7c539a4dd6b1c5e114e45e3918b233fd693da420 |
| lexicon:single-disk-point-of-failure | anti-pattern | Single-Disk Point of Failure | Storing data on a single disk with no redundancy, so that one disk's failure loses everything. | https://banes-lab.com/json/records/lexicon/single-disk-point-of-failure | https://banes-lab.com/records/lexicon/single-disk-point-of-failure.md | 3767 | ba90d2dd38e17e08a8555ba6a3c964dc22a4f5b98877bca586fae332cb4ed2b7 |
| lexicon:write-amplification | quality-attribute | Write Amplification | The degree to which maintaining parity on writes multiplies the underlying disk writes for each logical write. | https://banes-lab.com/json/records/lexicon/write-amplification | https://banes-lab.com/records/lexicon/write-amplification.md | 4148 | 098067d143e596922de82c1824b2e799340647b858f407f01da4f101fd6a5141 |
| lexicon:recovery-policy | technique | Recovery Policy | A technique for declaring, per failure class, the action the system takes to restore service and who is told. | https://banes-lab.com/json/records/lexicon/recovery-policy | https://banes-lab.com/records/lexicon/recovery-policy.md | 4177 | e47f9589f1cdf04c3c977607d123d1f1cace7d6dbd1a9ac8dc91659e351df74d |
| lexicon:expand-contract-migration | technique | Expand-Contract Migration | A technique for changing a schema in steps, adding the new shape, moving every reader and writer, then removing the old shape. | https://banes-lab.com/json/records/lexicon/expand-contract-migration | https://banes-lab.com/records/lexicon/expand-contract-migration.md | 4114 | 4e0da2807a798fa9e5f8a74fc7f96e60fe58446b93e6d1d054131c8f680d6577 |
| lexicon:dual-read-and-write | technique | Dual Read and Write | A technique for writing to both the old and the new store and comparing reads during a migration, until the new store is trusted. | https://banes-lab.com/json/records/lexicon/dual-read-and-write | https://banes-lab.com/records/lexicon/dual-read-and-write.md | 3226 | bb53f2573930f20d83cc87f339a849266c2df451369a113afa562e83453b8c46 |
| lexicon:rollback-plan | technique | Rollback Plan | A technique for stating before a release how it is undone and testing that the undo works. | https://banes-lab.com/json/records/lexicon/rollback-plan | https://banes-lab.com/records/lexicon/rollback-plan.md | 4415 | f00dfaa1a2e4789687f415264f207ee3cfe350878ef523c6f4403f55c8aa3d9f |
| lexicon:small-batch-release | technique | Small-Batch Release | A technique for shipping changes in small increments, so each release has a small blast radius. | https://banes-lab.com/json/records/lexicon/small-batch-release | https://banes-lab.com/records/lexicon/small-batch-release.md | 4094 | 74debfd8e8ecdf03739ea2e094e80f5c448d075a939f14fa1917745ed1d63f81 |
| lexicon:backup | technique | Backup | A technique for copying data to separate storage on a schedule, so it can be restored after loss or corruption. | https://banes-lab.com/json/records/lexicon/backup | https://banes-lab.com/records/lexicon/backup.md | 3161 | 6ca377479877185076f99226be9435e79e5a6a526255dbc3919355ec954942fc |
| lexicon:automate-the-runbook | technique | Automate the Runbook | A technique for turning repeated manual operational steps into a script the system runs and logs. | https://banes-lab.com/json/records/lexicon/automate-the-runbook | https://banes-lab.com/records/lexicon/automate-the-runbook.md | 4070 | 011fcd398d5f30b10b589decc03f357c1e5ec324d85da5b2db09cf58dbabb6bf |
| lexicon:autoscaling-policy | technique | Autoscaling Policy | A technique for declaring the load signals and limits by which the number of instances grows and shrinks. | https://banes-lab.com/json/records/lexicon/autoscaling-policy | https://banes-lab.com/records/lexicon/autoscaling-policy.md | 4979 | cb0465397b1604185b8ab7b0fcf10ebbc341c419febfdec6e0119f8c66886e4d |
| lexicon:flexible-input | quality-attribute | Flexible Input | The degree to which strictly validating every payload rejects the loosely-shaped input a caller might legitimately send. | https://banes-lab.com/json/records/lexicon/flexible-input | https://banes-lab.com/records/lexicon/flexible-input.md | 3998 | 6c44ed7ce28d0db476c6a8b8233552b58e7124cd4a00e95727be29008fe9816a |
| lexicon:untyped-payloads | anti-pattern | Untyped Payloads | Accepting data at a boundary with no schema, so malformed or unexpected shapes flow in unchecked. | https://banes-lab.com/json/records/lexicon/untyped-payloads | https://banes-lab.com/records/lexicon/untyped-payloads.md | 4544 | 3fa2c58d86f7b5dafec3308707bf22bb5d16ae4ec1e7b1a92bead349d42e6d75 |
| lexicon:dynamic-untyped-boundaries | anti-pattern | Dynamic Untyped Boundaries | Passing untyped values across module or service boundaries, so type errors surface only at runtime. | https://banes-lab.com/json/records/lexicon/dynamic-untyped-boundaries | https://banes-lab.com/records/lexicon/dynamic-untyped-boundaries.md | 4496 | 800864dccd54260399923ebbf5b45c4a26eb3740b4be9e64a2af4f80e719d8a6 |
| lexicon:explicit-types | constraint | Explicit Types | The requirement that values crossing a boundary carry explicit, declared types rather than open-ended ones. | https://banes-lab.com/json/records/lexicon/explicit-types | https://banes-lab.com/records/lexicon/explicit-types.md | 3191 | d1ec8a87fee9ef24bf020ce5d8138f68a90f9acee2ae42da191041ee34782f20 |
| lexicon:rapid-scripting | quality-attribute | Rapid Scripting | The degree to which requiring explicit types slows the quick, exploratory coding that dynamic typing allows. | https://banes-lab.com/json/records/lexicon/rapid-scripting | https://banes-lab.com/records/lexicon/rapid-scripting.md | 3955 | d9b8f535d4b4281a7979144adb21a37b79dffe12611e38cd83b2cf384316bde7 |
| lexicon:bounded-context-autonomy | quality-attribute | Bounded Context Autonomy | The degree to which enforcing one canonical model limits each bounded context's freedom to model its own domain. | https://banes-lab.com/json/records/lexicon/bounded-context-autonomy | https://banes-lab.com/records/lexicon/bounded-context-autonomy.md | 4561 | 2c88b2dd5533d6cb061870fba6c4924868ffb1a2ed545dd1cdd3144004e2a8fa |
| lexicon:multiple-competing-models | anti-pattern | Multiple Competing Models | Several inconsistent models of the same concept coexisting, so translations between them drift and conflict. | https://banes-lab.com/json/records/lexicon/multiple-competing-models | https://banes-lab.com/records/lexicon/multiple-competing-models.md | 4094 | 8e5930f26aaca596dcc9febe15f0fb5f328db372c89f3bc024795c6be0ce0eb9 |
| lexicon:normalized-translation | capability | Normalized Translation | The ability to translate between systems through one shared canonical form rather than many pairwise mappings. | https://banes-lab.com/json/records/lexicon/normalized-translation | https://banes-lab.com/records/lexicon/normalized-translation.md | 3275 | 689c687e3e1194d5c10567dce60128e6e743467259551bd866349e00d496a619 |
| lexicon:bounded-context-purity | quality-attribute | Bounded Context Purity | The degree to which sharing one enterprise data model erodes the conceptual purity of each bounded context. | https://banes-lab.com/json/records/lexicon/bounded-context-purity | https://banes-lab.com/records/lexicon/bounded-context-purity.md | 4127 | 281e413887d85844c7717c97f82478337581e5fe0571f283950554b4fa3e9ed2 |
| lexicon:cross-system-mapping | capability | Cross-System Mapping | The ability to map data between systems through a single shared canonical representation. | https://banes-lab.com/json/records/lexicon/cross-system-mapping | https://banes-lab.com/records/lexicon/cross-system-mapping.md | 3246 | a0e84084880f03aa6c720ed897ed9088510c3bb9fa4172431467b06b4e86290c |
| lexicon:local-model-autonomy | quality-attribute | Local Model Autonomy | The degree to which a bounded context is free to define and evolve its own data model independently of a shared canonical one. | https://banes-lab.com/json/records/lexicon/local-model-autonomy | https://banes-lab.com/records/lexicon/local-model-autonomy.md | 4650 | 54395fe4817d251988bc2f00712703ee0b07d21df44d57cd758e4dbbe4a73820 |
| lexicon:service-specific-schemas | quality-attribute | Service-Specific Schemas | The degree to which a shared canonical schema competes with each service's need for its own tailored schema. | https://banes-lab.com/json/records/lexicon/service-specific-schemas | https://banes-lab.com/records/lexicon/service-specific-schemas.md | 4086 | 22f81690091995c8edf245b71017e0316805b23bccdf0d3bab404461ed36beb1 |
| lexicon:ambiguous-encoding | anti-pattern | Ambiguous Encoding | Representing the same value in multiple encodings without normalizing, so equal values compare as different. | https://banes-lab.com/json/records/lexicon/ambiguous-encoding | https://banes-lab.com/records/lexicon/ambiguous-encoding.md | 3661 | 087df28632b8e4dda342e22219c42c6888cb70cf404a4bd5af8c8dd64c00384e |
| lexicon:canonical-format | constraint | Canonical Format | The requirement that a single normalized form be defined for values before they are compared or stored. | https://banes-lab.com/json/records/lexicon/canonical-format | https://banes-lab.com/records/lexicon/canonical-format.md | 3170 | 476a8180210317f6c7c13b88ca4d6cbaff86c55238e1d81c6cf228ae4678a723 |
| lexicon:deduplication | capability | Deduplication | The ability to recognize and collapse values that are equivalent once reduced to canonical form. | https://banes-lab.com/json/records/lexicon/deduplication | https://banes-lab.com/records/lexicon/deduplication.md | 3631 | 1c9f84ac6b56a08c4abff272edb6a88b39458e66b88ae05cf91b41487088951d |
| lexicon:lossless-preservation | quality-attribute | Lossless Preservation | The degree to which reducing values to a canonical form can discard distinctions the original preserved. | https://banes-lab.com/json/records/lexicon/lossless-preservation | https://banes-lab.com/records/lexicon/lossless-preservation.md | 4005 | adf5673c234b1c2c78fb22a53a92bb31de39aa9880df1df48350057a33dd2136 |
| lexicon:security-checks | capability | Security Checks | The ability to apply security checks reliably by first reducing input to one unambiguous form. | https://banes-lab.com/json/records/lexicon/security-checks | https://banes-lab.com/records/lexicon/security-checks.md | 3206 | 3af1d439bc59dee49d64ce63af3f8554ce192346055e6cd148f01c3043bfc7c8 |
| lexicon:canonical-definition | constraint | Canonical Definition | The requirement that each fact have one authoritative definition that all consumers reference. | https://banes-lab.com/json/records/lexicon/canonical-definition | https://banes-lab.com/records/lexicon/canonical-definition.md | 3655 | 87d2bbfa543ba01567acd3fc416a4bd01620c036009ff1f88ab6a29aa17ed0cd |
| lexicon:duplicated-authority | anti-pattern | Duplicated Authority | Two or more places each claiming to own the same fact, so they drift and disagree over time. | https://banes-lab.com/json/records/lexicon/duplicated-authority | https://banes-lab.com/records/lexicon/duplicated-authority.md | 5881 | 650cadb2cdce3dbe838feb957edea853bfffb9e07a6f3ef622140a7ebdf731c4 |
| lexicon:data-semantics | constraint | Data Semantics | The requirement that the meaning and dependencies of data be understood before it is decomposed into relations. | https://banes-lab.com/json/records/lexicon/data-semantics | https://banes-lab.com/records/lexicon/data-semantics.md | 3220 | 8f7152979092907a90b698650207fd1e971e17e2463ee3212b5bf96ef899da59 |
| lexicon:denormalized-read-models | pattern | Denormalized Read Models | A read-optimized model that deliberately duplicates data to serve queries fast, trading storage and write cost for read speed. | https://banes-lab.com/json/records/lexicon/denormalized-read-models | https://banes-lab.com/records/lexicon/denormalized-read-models.md | 4049 | 7d065e0930c7fcdb86fe61193048c6b11933bc6e13c476b2b0d6938216c055d2 |
| lexicon:non-redundant-storage | capability | Non-Redundant Storage | The ability to store each fact once, so it cannot drift out of sync with copies and no update anomaly can arise. | https://banes-lab.com/json/records/lexicon/non-redundant-storage | https://banes-lab.com/records/lexicon/non-redundant-storage.md | 3314 | b14215d5c132e1db598582cba99d2ab491c31b78a0a5554c60e9a6604f193450 |
| lexicon:query-performance | quality-attribute | Query Performance | The degree to which splitting data across normalized relations forces costly joins on read. | https://banes-lab.com/json/records/lexicon/query-performance | https://banes-lab.com/records/lexicon/query-performance.md | 4462 | 330929e5c5f00afed26ef6ae555e2014f64fc2c46278f92a86626e1d3e0bf98a |
| lexicon:reduced-redundancy | capability | Reduced Redundancy | The ability to eliminate duplicated facts by referencing a single stored copy. | https://banes-lab.com/json/records/lexicon/reduced-redundancy | https://banes-lab.com/records/lexicon/reduced-redundancy.md | 3137 | 42a636f91a105b987e0cf7447087c49d598b83799361ca99825a455bfd70576b |
| lexicon:disambiguation | capability | Disambiguation | The ability to give each concept one unambiguous name and meaning across a domain. | https://banes-lab.com/json/records/lexicon/disambiguation | https://banes-lab.com/records/lexicon/disambiguation.md | 3215 | acb3685946829505c3c48baf70d13a28afe93ebc63e65bb5f399bbb993649477 |
| lexicon:polysemy-across-contexts | quality-attribute | Polysemy Across Contexts | The degree to which one term legitimately carries different meanings in different bounded contexts. | https://banes-lab.com/json/records/lexicon/polysemy-across-contexts | https://banes-lab.com/records/lexicon/polysemy-across-contexts.md | 4122 | 876535761c60176a1b7733f187401ac8b73622275cc7d8aa2352b51c9542f040 |
| lexicon:cross-context-terminology | quality-attribute | Cross-Context Terminology | The degree to which agreeing on shared terms strains against the distinct vocabularies different contexts need. | https://banes-lab.com/json/records/lexicon/cross-context-terminology | https://banes-lab.com/records/lexicon/cross-context-terminology.md | 4158 | e5d446b9ca83243d1b3e44688c36a02b1e986b6b1520b7040b10c17380b4fd30 |
| lexicon:domain-collaboration | constraint | Domain Collaboration | The requirement that domain experts and developers collaborate to agree on shared terminology. | https://banes-lab.com/json/records/lexicon/domain-collaboration | https://banes-lab.com/records/lexicon/domain-collaboration.md | 3287 | 7e2227fb92cff761308125532d223b55b59364d6dda20f4504bb861d123e47c3 |
| lexicon:technical-domain-mismatch | anti-pattern | Technical/Domain Mismatch | Naming code in technical terms disconnected from the domain, so experts and developers talk past each other. | https://banes-lab.com/json/records/lexicon/technical-domain-mismatch | https://banes-lab.com/records/lexicon/technical-domain-mismatch.md | 3684 | 8860b6aa06908c06dfc412a971c7b948ad33d60a637372a5768e28c24d92a368 |
| lexicon:ambiguous-api | anti-pattern | Ambiguous API | An interface whose names and parameters hide what it does, so callers must guess or read the implementation. | https://banes-lab.com/json/records/lexicon/ambiguous-api | https://banes-lab.com/records/lexicon/ambiguous-api.md | 4648 | 7c57284bc45589356758a02382f625b39d4975a021dc3cfbdd2e8ed870ce5efe |
| lexicon:clear-semantics | constraint | Clear Semantics | The requirement that an interface's names convey what each operation does and expects. | https://banes-lab.com/json/records/lexicon/clear-semantics | https://banes-lab.com/records/lexicon/clear-semantics.md | 3691 | a11dee6f6070479ef742c878a226f55ae42705d4166a331adb6325748f2ca0e1 |
| lexicon:concise-naming | quality-attribute | Concise Naming | The degree to which naming an interface fully for clarity works against keeping names short. | https://banes-lab.com/json/records/lexicon/concise-naming | https://banes-lab.com/records/lexicon/concise-naming.md | 5021 | 7e655bab4222a7f347cb5702f441279377931f073b561835f490abfe3411df9c |
| lexicon:correct-usage | capability | Correct Usage | The ability of callers to use an interface correctly because its names reveal its intent. | https://banes-lab.com/json/records/lexicon/correct-usage | https://banes-lab.com/records/lexicon/correct-usage.md | 3198 | 6d7fc11d7d9524ec67f9caa89c67d57946ea4843eccdbce0e8fa753c9ae1182c |
| lexicon:naming-consistency | constraint | Naming Consistency | The requirement that names for the same concept be used consistently across an interface. | https://banes-lab.com/json/records/lexicon/naming-consistency | https://banes-lab.com/records/lexicon/naming-consistency.md | 4213 | f99123cf32bd61b350acb0f08083e4b0fc418ed5fab0b8e65d5a20ee85a03672 |
| lexicon:clever-abstractions | quality-attribute | Clever Abstractions | The degree to which clever, non-obvious abstractions trade familiarity for surprise to the reader. | https://banes-lab.com/json/records/lexicon/clever-abstractions | https://banes-lab.com/records/lexicon/clever-abstractions.md | 4091 | 465717ddc5c6c1869285fabf353177c386261abdbf8013b1e05bd1c90cb27797 |
| lexicon:convention | constraint | Convention | The requirement that a design follow shared naming, placement and behavior conventions, so its parts can be found automatically and behave as expected. | https://banes-lab.com/json/records/lexicon/convention | https://banes-lab.com/records/lexicon/convention.md | 4129 | 9db8eb6f68e99482ceec884c4f25b86d310aa99555a716f84563e04c14af0522 |
| lexicon:safe-use | capability | Safe Use | The ability to use an interface safely because it behaves the way its name and shape suggest. | https://banes-lab.com/json/records/lexicon/safe-use | https://banes-lab.com/records/lexicon/safe-use.md | 3232 | 3c998d4952a9b810167303145115ac2d120c738203c65775400f598ef4fcc733 |
| lexicon:duplicated-denormalized-columns | anti-pattern | Duplicated Denormalized Columns | The same fact copied into many columns and rows, so updates must touch every copy or leave them inconsistent. | https://banes-lab.com/json/records/lexicon/duplicated-denormalized-columns | https://banes-lab.com/records/lexicon/duplicated-denormalized-columns.md | 4079 | 34a3a3e34607aa2200bfbdfe65cb680a160de3bad98ed6b956c3add1879247ae |
| lexicon:functional-dependencies | constraint | Functional Dependencies | The requirement that the dependencies determining which attributes fix others be identified before decomposing a schema. | https://banes-lab.com/json/records/lexicon/functional-dependencies | https://banes-lab.com/records/lexicon/functional-dependencies.md | 3325 | 6beef5d6fee13fff764e4ac8d5f60428cd1b8d4d85535ecd6d2e9553cb15c872 |
| lexicon:read-performance | quality-attribute | Read Performance | The degree to which normalizing a schema into many relations forces joins that slow reads. | https://banes-lab.com/json/records/lexicon/read-performance | https://banes-lab.com/records/lexicon/read-performance.md | 4126 | a71e025b404c4f964dc4d3a8a4559a043745f730a8f7774bde26c9ca40d534da |
| lexicon:introduce-discriminated-union | technique | Introduce Discriminated Union | A technique for modeling a value that takes one of several shapes as a union whose variants carry a tag the type checker reads. | https://banes-lab.com/json/records/lexicon/introduce-discriminated-union | https://banes-lab.com/records/lexicon/introduce-discriminated-union.md | 4186 | 214eb52b4853feba9d4bd9c8c999e9ea1def8b3d58238f9f31046c51dcbb8b8d |
| lexicon:narrow-type | technique | Narrow Type | A technique for replacing a broad type with one that admits only the values the domain allows. | https://banes-lab.com/json/records/lexicon/narrow-type | https://banes-lab.com/records/lexicon/narrow-type.md | 4883 | eb2915ef937eb604180920dc22b6b26648515b52924995e075f0b0e3ea1769b1 |
| lexicon:define-absence-semantics | technique | Define Absence Semantics | A technique for choosing one representation for a missing value and stating what it means at the boundary. | https://banes-lab.com/json/records/lexicon/define-absence-semantics | https://banes-lab.com/records/lexicon/define-absence-semantics.md | 3138 | 2f79bd1f4096044b4d1288467bce6830a505b1695fc88bae23297d9a85749943 |
| lexicon:binary-schema-encoding | technique | Binary Schema Encoding | A technique for serializing messages in a compact binary format whose schema the reader and writer share. | https://banes-lab.com/json/records/lexicon/binary-schema-encoding | https://banes-lab.com/records/lexicon/binary-schema-encoding.md | 3243 | aa801f6bf7e063ed4d76e11d93e0952d3083b19267ba22fd3172a534eeaa2637 |
| lexicon:schema-registry | technique | Schema Registry | A technique for storing every published schema and its versions in one registry that producers and consumers check against. | https://banes-lab.com/json/records/lexicon/schema-registry | https://banes-lab.com/records/lexicon/schema-registry.md | 4775 | b745fafd568dab2d90896c06f54536574dbaed7f12cdc2f5aebe2d1990649cf8 |
| lexicon:ad-hoc-permission-checks | anti-pattern | Ad-Hoc Permission Checks | Authorization logic scattered inline throughout the codebase instead of centralized, leaving checks inconsistent and easy to omit. | https://banes-lab.com/json/records/lexicon/ad-hoc-permission-checks | https://banes-lab.com/records/lexicon/ad-hoc-permission-checks.md | 3323 | 10c980dce679d5129f1239d204947dff3f20cb2da56e8ba2455f31f5160b3723 |
| lexicon:ambient-credential-trust | anti-pattern | Ambient-Credential Trust | Treating any request that carries ambient credentials, such as a session cookie, as legitimate without verifying its origin or intent. | https://banes-lab.com/json/records/lexicon/ambient-credential-trust | https://banes-lab.com/records/lexicon/ambient-credential-trust.md | 3759 | 7c0bfba9ab10ee8321fc2105d8e743528d0b93322ab2f97cae8240f13877a5fa |
| lexicon:anonymous-sensitive-access | anti-pattern | Anonymous Sensitive Access | Permitting access to sensitive resources without first establishing the caller's identity. | https://banes-lab.com/json/records/lexicon/anonymous-sensitive-access | https://banes-lab.com/records/lexicon/anonymous-sensitive-access.md | 3713 | 81c3b8c4bdf9cc55d1e20251a911b219d088c163e36722c8d0afab634381c07b |
| lexicon:assumption-driven-security | anti-pattern | Assumption-Driven Security | Designing defenses around assumed threats rather than a deliberate analysis of realistic attack vectors. | https://banes-lab.com/json/records/lexicon/assumption-driven-security | https://banes-lab.com/records/lexicon/assumption-driven-security.md | 3772 | f638fe1c89bf735af221491385a74bbfdc868f6e7f2e341cafcac705f9f95769 |
| lexicon:authenticated-equals-authorized | anti-pattern | Authenticated-Equals-Authorized | Conflating authentication with authorization, so any authenticated caller is granted access without a permission check. | https://banes-lab.com/json/records/lexicon/authenticated-equals-authorized | https://banes-lab.com/records/lexicon/authenticated-equals-authorized.md | 3305 | 0be5f5b27349167fc25ec305c8cce6a0099600df558a0702d46621bd5d31788c |
| lexicon:broad-admin-access | anti-pattern | Broad Admin Access | Granting sweeping administrative privileges by default instead of the least access each role requires. | https://banes-lab.com/json/records/lexicon/broad-admin-access | https://banes-lab.com/records/lexicon/broad-admin-access.md | 3683 | 86e7216f74f14a130aabc13d5a79fb0daa14328ffaf3267d5fb3866977ab8d81 |
| lexicon:hardcoded-rules | anti-pattern | Hardcoded Rules | Embedding access rules directly in code, so changing policy requires a code change and cannot respond to runtime attributes. | https://banes-lab.com/json/records/lexicon/hardcoded-rules | https://banes-lab.com/records/lexicon/hardcoded-rules.md | 4198 | 3b9dda1ff7dd5a2967790e43e059840aaf980bd5594515f0a2db392c9bf35973 |
| lexicon:hardcoded-secrets | anti-pattern | Hardcoded Secrets | Embedding credentials, keys, or tokens directly in source or configuration, exposing them to anyone who can read it. | https://banes-lab.com/json/records/lexicon/hardcoded-secrets | https://banes-lab.com/records/lexicon/hardcoded-secrets.md | 3723 | 130a6012262fb22a71c4a6a272c33930d443df66c29774d8a6a63a01f3d134d7 |
| lexicon:immortal-client-trusted-session | anti-pattern | Immortal Client-Trusted Session | A session that never expires and is trusted from client-supplied state alone, so a captured token grants indefinite access. | https://banes-lab.com/json/records/lexicon/immortal-client-trusted-session | https://banes-lab.com/records/lexicon/immortal-client-trusted-session.md | 3726 | fa9c1c98368e9452bd3a4315eb8fc8df6b78007b35068ee88b4c2f55ac19d59e |
| lexicon:insecure-defaults | anti-pattern | Insecure Defaults | Shipping default settings that favor convenience over safety, leaving a system exposed unless it is explicitly hardened. | https://banes-lab.com/json/records/lexicon/insecure-defaults | https://banes-lab.com/records/lexicon/insecure-defaults.md | 3732 | 2a415542aeb92b3be0b0c2735357a491533602c011f031b774357c37c7d265b7 |
| lexicon:manual-only-review | anti-pattern | Manual-Only Review | Relying solely on human review to catch policy violations, which neither scales nor reliably covers every case. | https://banes-lab.com/json/records/lexicon/manual-only-review | https://banes-lab.com/records/lexicon/manual-only-review.md | 3692 | d2b927ada8d81e4364d562c2f8114fad3d506ebba492e32ffe948143efefe25b |
| lexicon:plaintext-sensitive-storage | anti-pattern | Plaintext Sensitive Storage | Storing sensitive data unencrypted at rest, exposing it to anyone who reaches the underlying storage. | https://banes-lab.com/json/records/lexicon/plaintext-sensitive-storage | https://banes-lab.com/records/lexicon/plaintext-sensitive-storage.md | 3703 | f6c19ec13dd07d424464c83735a790b792924bd5ba6e33b47645259cdf31659f |
| lexicon:plaintext-transport | anti-pattern | Plaintext Transport | Sending data over an unencrypted channel, exposing it to interception and tampering in transit. | https://banes-lab.com/json/records/lexicon/plaintext-transport | https://banes-lab.com/records/lexicon/plaintext-transport.md | 3765 | da582da793aabb8eb9e20f2aff6340f5f11755de39253442181171b371091f93 |
| lexicon:point-in-time-audit-only | anti-pattern | Point-in-Time Audit Only | Verifying compliance only at isolated audit moments, leaving the intervals between checks unmonitored for drift. | https://banes-lab.com/json/records/lexicon/point-in-time-audit-only | https://banes-lab.com/records/lexicon/point-in-time-audit-only.md | 4077 | a5586501a1b74d490ac44ca7b70776dbced6827a0b2d66dffa33a074b48e3d9e |
| lexicon:raw-output-rendering | anti-pattern | Raw Output Rendering | Emitting untrusted data into output without encoding it for its context, enabling injection attacks such as cross-site scripting. | https://banes-lab.com/json/records/lexicon/raw-output-rendering | https://banes-lab.com/records/lexicon/raw-output-rendering.md | 3728 | 5e9444e3e0475c30e452fa8805262ab776be36a752d2a2cbcbe56e8874b4ca43 |
| lexicon:security-as-afterthought | anti-pattern | Security as Afterthought | Deferring security concerns until late in development, when vulnerabilities are costly and difficult to remediate. | https://banes-lab.com/json/records/lexicon/security-as-afterthought | https://banes-lab.com/records/lexicon/security-as-afterthought.md | 3734 | 046a4aa9e7cd4849f4d7954967785b03a2b48fb687eb2a23aef50284720fb436 |
| lexicon:single-control-reliance | anti-pattern | Single Control Reliance | Depending on one security control with no layered defenses, so a single bypass compromises the whole system. | https://banes-lab.com/json/records/lexicon/single-control-reliance | https://banes-lab.com/records/lexicon/single-control-reliance.md | 3724 | ad69feebc57d8a31ede16d04cbaeeaf99c96ac053e1a865f23fbe732f76a2cd2 |
| lexicon:string-concatenated-sql | anti-pattern | String-Concatenated SQL | Assembling SQL queries by concatenating untrusted input into strings, opening the system to SQL injection. | https://banes-lab.com/json/records/lexicon/string-concatenated-sql | https://banes-lab.com/records/lexicon/string-concatenated-sql.md | 3827 | 3979fb96f556fab725f989598a35d45872c0718273dc4013a75ff07ad3541ac3 |
| lexicon:trusted-internal-network-assumption | anti-pattern | Trusted Internal Network Assumption | Assuming that traffic originating inside the network perimeter is inherently trustworthy, ignoring insider and lateral-movement threats. | https://banes-lab.com/json/records/lexicon/trusted-internal-network-assumption | https://banes-lab.com/records/lexicon/trusted-internal-network-assumption.md | 3865 | e5c9f5d11b251f6d0d60738adb547a9e5a9c8c4f31933efc3780bdc53c13b765 |
| lexicon:trusting-external-input | anti-pattern | Trusting External Input | Accepting external input as well-formed and safe without validating it, exposing the system to malformed or malicious data. | https://banes-lab.com/json/records/lexicon/trusting-external-input | https://banes-lab.com/records/lexicon/trusting-external-input.md | 4661 | 68047bf7e92a655d559bcf178bfb21734a256b0f38ff1b8516aeec02aec6aa65 |
| lexicon:unbounded-autonomy | anti-pattern | Unbounded Autonomy | Allowing an actor or component to act without governance limits, so unsafe or unauthorized actions go unchecked. | https://banes-lab.com/json/records/lexicon/unbounded-autonomy | https://banes-lab.com/records/lexicon/unbounded-autonomy.md | 4126 | 68c79a6bc9ed52dd94f9fc85ef51a8826ffd56dfc064851ed8dc4d80deec898b |
| lexicon:uncontrolled-change | anti-pattern | Uncontrolled Change | Permitting changes to a controlled system without review, approval, or record, undermining compliance and traceability. | https://banes-lab.com/json/records/lexicon/uncontrolled-change | https://banes-lab.com/records/lexicon/uncontrolled-change.md | 3644 | c369277e13087585f75c12093e2534e9e70ffd5abba3998800d38513a6944deb |
| lexicon:unnecessary-public-surface | anti-pattern | Unnecessary Public Surface | Exposing more endpoints, ports, or interfaces publicly than the function requires, enlarging the attack surface. | https://banes-lab.com/json/records/lexicon/unnecessary-public-surface | https://banes-lab.com/records/lexicon/unnecessary-public-surface.md | 3775 | fcb4bfd2fe383bb146c4454b041c5bc9136db3f6e84578be836662a5875fdc94 |
| lexicon:unrestricted-access | anti-pattern | Unrestricted Access | Permitting access to a resource with no controls, so any caller can invoke any operation. | https://banes-lab.com/json/records/lexicon/unrestricted-access | https://banes-lab.com/records/lexicon/unrestricted-access.md | 3944 | 3735c8bfc8af719f8a39ef4c1f69b80a9fa1dc02e0b13311dfbf7bab9eda7e73 |
| lexicon:assets | artifact | Assets | The data, systems, and capabilities of value that a threat model enumerates as the things worth protecting. | https://banes-lab.com/json/records/lexicon/assets | https://banes-lab.com/records/lexicon/assets.md | 3180 | 0e1f99b889569b1ca9871158c139cf1c46358d316b2b2cc93931368b357d975d |
| lexicon:attribute-definitions | artifact | Attribute Definitions | Declared descriptions of the subject, resource, action, and environment attributes that an access policy evaluates. | https://banes-lab.com/json/records/lexicon/attribute-definitions | https://banes-lab.com/records/lexicon/attribute-definitions.md | 3268 | c927f3e54751d00b7ce7ef19d1359e0667d5c3749ffb51ee3046610ea0b56aee |
| lexicon:authenticated-principal | model | Authenticated Principal | The verified identity of the user or service on whose behalf a request executes, against which permissions are checked. | https://banes-lab.com/json/records/lexicon/authenticated-principal | https://banes-lab.com/records/lexicon/authenticated-principal.md | 3252 | 33ff8cf48ad8809977878e68112b200079bc67406a381ddc12ce8a17f519264f |
| lexicon:authorization-policy | constraint | Authorization Policy | The declared set of rules determining which principals may perform which actions on which resources. | https://banes-lab.com/json/records/lexicon/authorization-policy | https://banes-lab.com/records/lexicon/authorization-policy.md | 3211 | 765333b148d3cdc1d152f687ccb1713939a299ffba319d56aa016e84c73fc095 |
| lexicon:consent-policy | constraint | Consent/Policy | The recorded permission and governing rules under which personal data may lawfully be collected and processed. | https://banes-lab.com/json/records/lexicon/consent-policy | https://banes-lab.com/records/lexicon/consent-policy.md | 3237 | afc37020133b9495802bb9856266d678641f0508865646b7e8dfd7529e781997 |
| lexicon:context-aware-encoding | technique | Context-Aware Encoding | Choosing an output encoding matched to the destination context, such as HTML, an attribute, a URL or a script, so data is neutralized wherever it lands. | https://banes-lab.com/json/records/lexicon/context-aware-encoding | https://banes-lab.com/records/lexicon/context-aware-encoding.md | 3708 | 8a0c2d715be5be07fd2cca5f941d15c9617c403a271335e0868454cace78359f |
| lexicon:continuous-authorization | activity | Continuous Authorization | The practice of re-verifying a caller's authorization on every request rather than trusting a single earlier check. | https://banes-lab.com/json/records/lexicon/continuous-authorization | https://banes-lab.com/records/lexicon/continuous-authorization.md | 3250 | 9ddd0ee614149a71e6ef6f64812dba5ec3fc8a5b2fddc396f0296d94c220cf11 |
| lexicon:controls | mechanism | Controls | The safeguards and countermeasures put in place to reduce security or compliance risk to an acceptable level. | https://banes-lab.com/json/records/lexicon/controls | https://banes-lab.com/records/lexicon/controls.md | 3939 | 47d4715351ced181e576468cbb197bee037889538d8d47c8deccf76cc144fda8 |
| lexicon:data-minimization | principle | Data Minimization | Collecting and retaining only the personal data strictly necessary for a stated purpose. | https://banes-lab.com/json/records/lexicon/data-minimization | https://banes-lab.com/records/lexicon/data-minimization.md | 3126 | 0e34ab64b77cd4aec11865182e79b862e3ccd058c2a4f0aae81666c3856f8e51 |
| lexicon:defined-policy | constraint | Defined Policy | An explicit, declared set of rules specifying what is permitted or denied, against which enforcement acts. | https://banes-lab.com/json/records/lexicon/defined-policy | https://banes-lab.com/records/lexicon/defined-policy.md | 3208 | 35c8d7ed09aa1b7bfea2446548b954be645d6fe7ab13d8edf81c22338a696db0 |
| lexicon:evidence-automation | capability | Evidence Automation | The ability to generate and collect compliance evidence automatically from live systems rather than assembling it by hand. | https://banes-lab.com/json/records/lexicon/evidence-automation | https://banes-lab.com/records/lexicon/evidence-automation.md | 3219 | 59c74f517c5744b7511a39d247000d7270826a6b419263763b79cada578c7e96 |
| lexicon:identity-proof | artifact | Identity Proof | The evidence a principal presents to establish its identity, such as a password, token, or certificate. | https://banes-lab.com/json/records/lexicon/identity-proof | https://banes-lab.com/records/lexicon/identity-proof.md | 3168 | c71debeed48c7305fedbe6cf0e782c92cae192fa4e530c766e4f897a45f333bb |
| lexicon:key-management | activity | Key Management | The activity of generating, distributing, rotating, and revoking cryptographic keys across their lifecycle. | https://banes-lab.com/json/records/lexicon/key-management | https://banes-lab.com/records/lexicon/key-management.md | 3620 | f7adde161a4ffcb7a205bf640f1a8a35a566a17789853d1e2d44258d6f4afd69 |
| lexicon:layered-controls | constraint | Layered Controls | The requirement that multiple independent safeguards protect a resource, so no single failure exposes it. | https://banes-lab.com/json/records/lexicon/layered-controls | https://banes-lab.com/records/lexicon/layered-controls.md | 3220 | d48ca8208d9653f60bf37bbd14f0a04fd25517c28175ac44630e8afcc633b630 |
| lexicon:machine-readable-policies | artifact | Machine-Readable Policies | Security or compliance policies expressed in a structured, executable format that tools can evaluate directly. | https://banes-lab.com/json/records/lexicon/machine-readable-policies | https://banes-lab.com/records/lexicon/machine-readable-policies.md | 3214 | 19a7d263d9d22c05b648330d4596a2f62b8c2b07cbf86395326fb9993f350e4d |
| lexicon:minimal-exposure | constraint | Minimal Exposure | The condition of exposing only the endpoints, ports, and capabilities strictly required. | https://banes-lab.com/json/records/lexicon/minimal-exposure | https://banes-lab.com/records/lexicon/minimal-exposure.md | 3268 | 3cb2568ac8095d99b75b3ced8fee060346de7fdaf3bf748e11a1ac4a7fc1b24e |
| lexicon:minimal-permissions | constraint | Minimal Permissions | The requirement that each principal hold only the permissions its function needs. | https://banes-lab.com/json/records/lexicon/minimal-permissions | https://banes-lab.com/records/lexicon/minimal-permissions.md | 3138 | d3fea5834f804745e34f4e93abd70fc85974408797d3597dc817b8ddbf400aba |
| lexicon:mitigation | activity | Mitigation | The activity of reducing a risk's likelihood or impact through deliberate countermeasures. | https://banes-lab.com/json/records/lexicon/mitigation | https://banes-lab.com/records/lexicon/mitigation.md | 3627 | 4495e66da9abed1a724e39bc7e0b9894a46f626df91e893bf9dc7647be003d85 |
| lexicon:policy-engine | mechanism | Policy Engine | A runtime component that evaluates access requests against declared policies and returns permit or deny decisions. | https://banes-lab.com/json/records/lexicon/policy-engine | https://banes-lab.com/records/lexicon/policy-engine.md | 3759 | ea62ef6a7a9ccb220e422e0a37345f6b19331a30786f4d7a9dda424b4d8885da |
| lexicon:query-parameter-binding | technique | Query Parameter Binding | Passing query values as bound parameters separate from the query text, so input can never alter the query structure. | https://banes-lab.com/json/records/lexicon/query-parameter-binding | https://banes-lab.com/records/lexicon/query-parameter-binding.md | 3288 | 47ed394e72b1a58221d7a83b14c5e526ec5b0405d1b251a33872a97657ecfc64 |
| lexicon:request-origin-verification | technique | Request Origin Verification | Confirming that a state-changing request originates from a trusted client, typically via a token or origin check. | https://banes-lab.com/json/records/lexicon/request-origin-verification | https://banes-lab.com/records/lexicon/request-origin-verification.md | 3216 | 64c9e43e42e6f8d9fdeb86ba8309fdb3640a37853d17878193d036a64b633830 |
| lexicon:review | activity | Review | The activity of examining a change or artifact against standards before it is accepted. | https://banes-lab.com/json/records/lexicon/review | https://banes-lab.com/records/lexicon/review.md | 5317 | e38d0b1f215227e8548f8a29b80f3cfce42d8e6acfb14bffbac912bc061b42f6 |
| lexicon:risk-identification | activity | Risk Identification | The activity of discovering and cataloguing the risks that could affect a system or objective. | https://banes-lab.com/json/records/lexicon/risk-identification | https://banes-lab.com/records/lexicon/risk-identification.md | 3129 | ddd51c89dd9237474648d17ebf8ab62137ea99acbdcba903fac52d48b7b4ed3e |
| lexicon:role-definitions | artifact | Role Definitions | Declared sets of permissions grouped into named roles that are assigned to principals. | https://banes-lab.com/json/records/lexicon/role-definitions | https://banes-lab.com/records/lexicon/role-definitions.md | 3219 | ed59301e590e0322fe21cc5ccad62326465aaac9b8f53faff49925edf77753fa |
| lexicon:rotation-policy | constraint | Rotation Policy | The specified interval and procedure by which secrets or keys must be replaced to limit the value of any single compromise. | https://banes-lab.com/json/records/lexicon/rotation-policy | https://banes-lab.com/records/lexicon/rotation-policy.md | 3189 | c06e2677469cb2bc209eab78c321f6ed8f5b682c54c98a39a5083810a1ea4067 |
| lexicon:secret-store | artifact | Secret Store | A dedicated, access-controlled repository that holds credentials and keys outside of application code. | https://banes-lab.com/json/records/lexicon/secret-store | https://banes-lab.com/records/lexicon/secret-store.md | 3169 | 7515e6ae80bda71b458ac31448e9f4baeb7abc58a19caa1ff12a041a9078c89c |
| lexicon:threat-scenarios | artifact | Threat Scenarios | Concrete descriptions of how an attacker might attempt to compromise a system, enumerated during threat modeling. | https://banes-lab.com/json/records/lexicon/threat-scenarios | https://banes-lab.com/records/lexicon/threat-scenarios.md | 3614 | ae2c0b4690c6c6e354b0d4e6e42483e401643d99ca14f6a3933f151d4fcf1dcd |
| lexicon:tls-mtls | mechanism | TLS/mTLS | Transport-layer protocols that encrypt a connection and, with mutual TLS, mutually authenticate both endpoints. | https://banes-lab.com/json/records/lexicon/tls-mtls | https://banes-lab.com/records/lexicon/tls-mtls.md | 3641 | 33ee0cce546f14ceabc0e8eec56cc2c2d8ab21a5e1cfd30cbd30aada55f91a2c |
| lexicon:trust-boundaries | model | Trust Boundaries | The demarcations in a system where the level of trust changes and data crossing them must be validated. | https://banes-lab.com/json/records/lexicon/trust-boundaries | https://banes-lab.com/records/lexicon/trust-boundaries.md | 3571 | f74fcc19c9ff322875c82efebd62861e0825282f26b27a74645ccef74c5c631d |
| lexicon:strong-identity | constraint | Strong Identity | The requirement that every actor prove a strong, verified identity before any access is granted. | https://banes-lab.com/json/records/lexicon/strong-identity | https://banes-lab.com/records/lexicon/strong-identity.md | 3207 | 04474518c6938717dfd83fefe7f9372796af2280498f749015f447d4d054cace |
| lexicon:validation-rules | constraint | Validation Rules | Declared constraints that input must satisfy, such as type, range, format and length, before it is accepted. | https://banes-lab.com/json/records/lexicon/validation-rules | https://banes-lab.com/records/lexicon/validation-rules.md | 3725 | 9eb320a608a8b99797404ac1a8fc161c47be68f679722fd9e11d0681a380068d |
| lexicon:automated-control | capability | Automated Control | The ability to enforce rules automatically at runtime without manual intervention. | https://banes-lab.com/json/records/lexicon/automated-control | https://banes-lab.com/records/lexicon/automated-control.md | 3215 | c9a660a9a8b6d81541cbf3ce317813cac023e77b6e99e0ceb3f098acaac17034 |
| lexicon:bounded-session-lifetime | quality-attribute | Bounded Session Lifetime | The degree to which a session's validity is time-limited so that access does not persist indefinitely. | https://banes-lab.com/json/records/lexicon/bounded-session-lifetime | https://banes-lab.com/records/lexicon/bounded-session-lifetime.md | 3335 | 0f9df04058143d1aa24824cbab98a7fb063a1e8f90e10c9c119ccb51adf5cd28 |
| lexicon:coarse-grained-permission-management | capability | Coarse-Grained Permission Management | The ability to manage access by assigning broad, role-level permission sets rather than per-individual grants. | https://banes-lab.com/json/records/lexicon/coarse-grained-permission-management | https://banes-lab.com/records/lexicon/coarse-grained-permission-management.md | 3384 | 7cc4dae5532f3113ceb5b1b9f89d8573dfa015a1d389acf4b1d69b357b6a45f0 |
| lexicon:compromise-containment | capability | Compromise Containment | The ability to keep a breach confined to one layer or segment so it cannot spread system-wide. | https://banes-lab.com/json/records/lexicon/compromise-containment | https://banes-lab.com/records/lexicon/compromise-containment.md | 3292 | e817f9eff7209107bb14e9416b0a0966f594268f79295bca7cf644d39c53c97d |
| lexicon:confidentiality | quality-attribute | Confidentiality | The degree to which data is kept secret from all but authorized parties. | https://banes-lab.com/json/records/lexicon/confidentiality | https://banes-lab.com/records/lexicon/confidentiality.md | 3282 | 53c253eb4e1447987231a37969d8a0054c63eb9a8aab236b2db888be7ee75c60 |
| lexicon:confidentiality-of-stored-data | quality-attribute | Confidentiality of Stored Data | The degree to which data held at rest remains unreadable to anyone without authorized access. | https://banes-lab.com/json/records/lexicon/confidentiality-of-stored-data | https://banes-lab.com/records/lexicon/confidentiality-of-stored-data.md | 3295 | 643d7d6cc88c143473e53581efe6bd17dba39536d4a9fded593b9d8cae4ff8a7 |
| lexicon:context-aware-authorization | capability | Context-Aware Authorization | The ability to base access decisions on the runtime context of a request, such as its attributes, its environment and the resource's state. | https://banes-lab.com/json/records/lexicon/context-aware-authorization | https://banes-lab.com/records/lexicon/context-aware-authorization.md | 3407 | 14f657fc0aa688b31ea64a0b110c8697a02b86c420ee88c45ac778b368be0b77 |
| lexicon:control-selection | activity | Control Selection | The activity of choosing which security controls to apply based on identified threats and their priority. | https://banes-lab.com/json/records/lexicon/control-selection | https://banes-lab.com/records/lexicon/control-selection.md | 3231 | 8272c386491f64c01b9f75bf2b1d09550d2aa4d133c0723ab1ea604ab8b2fd2d |
| lexicon:data-protection | capability | Data Protection | The ability to safeguard data against unauthorized access, loss, or disclosure throughout its lifecycle. | https://banes-lab.com/json/records/lexicon/data-protection | https://banes-lab.com/records/lexicon/data-protection.md | 3252 | cc526b0af8dc03c78e914c9f037277b9627363e468c1c59028c76a50bb42f841 |
| lexicon:fine-grained-access-control | capability | Fine-Grained Access Control | The ability to grant or deny access at a precise level using specific attributes rather than broad roles. | https://banes-lab.com/json/records/lexicon/fine-grained-access-control | https://banes-lab.com/records/lexicon/fine-grained-access-control.md | 3336 | 5a0962d8479e196aef52caca2c36bb6cbee51aba3d7d7a32ebc6b50760395c6e |
| lexicon:forged-request-rejection | capability | Forged-Request Rejection | The ability to detect and reject requests that a user did not intentionally initiate. | https://banes-lab.com/json/records/lexicon/forged-request-rejection | https://banes-lab.com/records/lexicon/forged-request-rejection.md | 3306 | fb66c49b3546d40a5d5fda0af90c1df22216591403d6c987c82458ba696ce9d4 |
| lexicon:identity-aware-authorization | capability | Identity-Aware Authorization | The ability to make access decisions grounded in a verified caller identity. | https://banes-lab.com/json/records/lexicon/identity-aware-authorization | https://banes-lab.com/records/lexicon/identity-aware-authorization.md | 3253 | b03506d0b5d95dbf25d1f2ebafd1032a962a28d0858872587703734b9e7f7bb2 |
| lexicon:injection-prevention | capability | Injection Prevention | The ability to stop untrusted input from being interpreted as executable code or commands. | https://banes-lab.com/json/records/lexicon/injection-prevention | https://banes-lab.com/records/lexicon/injection-prevention.md | 3293 | 0541da8892ac09e09b06cf57c8b0832b5f8747a50207b9a2ec8c80a0331d4354 |
| lexicon:injection-safe-data-access | capability | Injection-Safe Data Access | The ability to query data such that input can never be interpreted as part of the query structure. | https://banes-lab.com/json/records/lexicon/injection-safe-data-access | https://banes-lab.com/records/lexicon/injection-safe-data-access.md | 3227 | 5ec27397de10c320dc4582ddd9f282a70e143a8cc82a158c0ebf27968547af55 |
| lexicon:integrity | quality-attribute | Integrity | The degree to which data is protected from unauthorized or undetected alteration. | https://banes-lab.com/json/records/lexicon/integrity | https://banes-lab.com/records/lexicon/integrity.md | 3710 | 678ac08cce22c5324ac6fb0ecbd7c4ee0b58439b6bf97ca50fdb4a9a0e26be95 |
| lexicon:ongoing-assurance | capability | Ongoing Assurance | The ability to demonstrate continuously that controls remain effective, rather than only at audit time. | https://banes-lab.com/json/records/lexicon/ongoing-assurance | https://banes-lab.com/records/lexicon/ongoing-assurance.md | 3206 | 97b0adcc1527ea1600d396ea722900909b5d8943ea79e6764dae5d96d804a6c5 |
| lexicon:perimeterless-security | approach | Perimeterless Security | A security model that trusts no network location implicitly and verifies every request regardless of origin. | https://banes-lab.com/json/records/lexicon/perimeterless-security | https://banes-lab.com/records/lexicon/perimeterless-security.md | 3284 | 333a78aad78f210b088e284ee4b887ad2019c7162182df1e124f68c33e7bbe11 |
| lexicon:priority-based-controls | capability | Priority-Based Controls | The ability to apply controls in order of risk priority, addressing the greatest exposure first. | https://banes-lab.com/json/records/lexicon/priority-based-controls | https://banes-lab.com/records/lexicon/priority-based-controls.md | 3238 | 70ad271a4774305a9d94113b5ed3cef16e30fcd51b91fd0db874a77d65911717 |
| lexicon:privacy-compliance | quality-attribute | Privacy Compliance | The degree to which a system meets the privacy obligations imposed by law and policy. | https://banes-lab.com/json/records/lexicon/privacy-compliance | https://banes-lab.com/records/lexicon/privacy-compliance.md | 3259 | d0c4414302b76fd1e0fb9bd932800c6bf8101b40ef561cd827d989173ef28eee |
| lexicon:proactive-risk-reduction | capability | Proactive Risk Reduction | The ability to reduce risk by designing safeguards in from the start rather than patching flaws later. | https://banes-lab.com/json/records/lexicon/proactive-risk-reduction | https://banes-lab.com/records/lexicon/proactive-risk-reduction.md | 3253 | a281cc750f8350c2d948519dcdab068175feccd7eb8cf6a30ceb35795821f2f9 |
| lexicon:reduced-blast-radius | quality-attribute | Reduced Blast Radius | The degree to which the impact of a compromise is confined to a limited scope. | https://banes-lab.com/json/records/lexicon/reduced-blast-radius | https://banes-lab.com/records/lexicon/reduced-blast-radius.md | 3245 | 0595bd55b06e5bf8cbf1227d3ca32fdca80c25906de54419a6c0bebdc24ebe20 |
| lexicon:reduced-exploitability | quality-attribute | Reduced Exploitability | The degree to which fewer exposed features leave a system harder to exploit. | https://banes-lab.com/json/records/lexicon/reduced-exploitability | https://banes-lab.com/records/lexicon/reduced-exploitability.md | 3311 | bda10eff434be196307467cf6859a37c0d94b41b13349c347a671ad9910ad878 |
| lexicon:reduced-misconfiguration-risk | quality-attribute | Reduced Misconfiguration Risk | The degree to which safe defaults lower the chance of an insecure configuration. | https://banes-lab.com/json/records/lexicon/reduced-misconfiguration-risk | https://banes-lab.com/records/lexicon/reduced-misconfiguration-risk.md | 3273 | 0faaefeb38dcab38352e5cf696655aa60b399ef929f70f6515cb75237e1dbf8b |
| lexicon:regulatory-alignment | quality-attribute | Regulatory Alignment | The degree to which a system conforms to the laws and regulations that govern it. | https://banes-lab.com/json/records/lexicon/regulatory-alignment | https://banes-lab.com/records/lexicon/regulatory-alignment.md | 3233 | 2c89f9893466442b5cd0a856f4f3620f80783e3a762e41e117b3f92b4d5bc0f3 |
| lexicon:resource-protection | capability | Resource Protection | The ability to ensure that only permitted operations reach a protected resource. | https://banes-lab.com/json/records/lexicon/resource-protection | https://banes-lab.com/records/lexicon/resource-protection.md | 3181 | b47d609b3d077b44aa5894c451959142bdc3055ad713fe2d8f4361a28fc4822f |
| lexicon:revocable-access | capability | Revocable Access | The ability to withdraw a principal's access immediately when a session or grant is terminated. | https://banes-lab.com/json/records/lexicon/revocable-access | https://banes-lab.com/records/lexicon/revocable-access.md | 3239 | deb5b1fd2dfb67c1d145bbff998a7e4211cb4917758f27bd0b0c811c394f3162 |
| lexicon:safe-credential-handling | capability | Safe Credential Handling | The ability to store, transmit, and use credentials without exposing them. | https://banes-lab.com/json/records/lexicon/safe-credential-handling | https://banes-lab.com/records/lexicon/safe-credential-handling.md | 3185 | 984d5c09f457301c5fb2e1b0d3de8b6487d7bad581e0f2fd461984004b62d70c |
| lexicon:safe-rendering | capability | Safe Rendering | The ability to display untrusted data without allowing it to execute as markup or script. | https://banes-lab.com/json/records/lexicon/safe-rendering | https://banes-lab.com/records/lexicon/safe-rendering.md | 3215 | 37dcabdf7809c3594f4c2bf0c5be6824177485da87ec21203b8e8780156624f0 |
| lexicon:secure-communication | capability | Secure Communication | The ability to exchange data over a channel protected from interception and tampering. | https://banes-lab.com/json/records/lexicon/secure-communication | https://banes-lab.com/records/lexicon/secure-communication.md | 3216 | defd15ab92ea6ded677dc0dfa28e7f2085e20dd6fa356619d955d1a4dad7a468 |
| lexicon:secure-configuration | quality-attribute | Secure Configuration | The degree to which a system's settings and secrets are arranged to minimize exposure. | https://banes-lab.com/json/records/lexicon/secure-configuration | https://banes-lab.com/records/lexicon/secure-configuration.md | 3191 | d6b8be0c5fccf94378423dc7ce97c45f34032262f238a1caadc2990e7a07c13c |
| lexicon:zero-trust | approach | Zero Trust | A security stance that grants no implicit trust and continuously verifies every access request regardless of its source. | https://banes-lab.com/json/records/lexicon/zero-trust | https://banes-lab.com/records/lexicon/zero-trust.md | 3272 | 233798283c2df4d30ddcad2f51d240f0f7b630e2fe900f38d3476b0ebfe6b6b5 |
| lexicon:analytics-personalization | capability | Analytics/Personalization | The ability to analyze collected data and tailor experiences to individuals, in tension with strict data minimization. | https://banes-lab.com/json/records/lexicon/analytics-personalization | https://banes-lab.com/records/lexicon/analytics-personalization.md | 4086 | 6fab4c5e255a3a65da2ac7ac847346ec4393cda4d140f616bfa5028f38cfc3e3 |
| lexicon:certificate-management | activity | Certificate Management | The activity of issuing, deploying, renewing, and revoking the digital certificates that transport encryption depends on. | https://banes-lab.com/json/records/lexicon/certificate-management | https://banes-lab.com/records/lexicon/certificate-management.md | 4150 | 5c50232e513ca1bed2d3652d47b6438a5bcb7a1b63d782a48235cef1b7a86438 |
| lexicon:client-complexity | quality-attribute | Client Complexity | The degree of additional effort a protective measure imposes on client implementations. | https://banes-lab.com/json/records/lexicon/client-complexity | https://banes-lab.com/records/lexicon/client-complexity.md | 4020 | 9d25b7e6c5f50693c14629779ba82fddafc40f40c95728f73baac1627e1e5e29 |
| lexicon:developer-ergonomics | quality-attribute | Developer Ergonomics | The degree to which a system is convenient and pleasant for developers to work with. | https://banes-lab.com/json/records/lexicon/developer-ergonomics | https://banes-lab.com/records/lexicon/developer-ergonomics.md | 4074 | c6477c4572de9c7dc028d4e6c9e7d3f98d9742b7ab1aa502364e5c9dadf2ce39 |
| lexicon:dynamic-query-flexibility | quality-attribute | Dynamic Query Flexibility | The degree of freedom to vary a query's structure at runtime, constrained when inputs must be bound as parameters. | https://banes-lab.com/json/records/lexicon/dynamic-query-flexibility | https://banes-lab.com/records/lexicon/dynamic-query-flexibility.md | 4164 | c6f611a52f7616089d9485d01dca99c7037fd7c308d53497602b0cc3e61bf4dd |
| lexicon:ease-of-initial-use | quality-attribute | Ease of Initial Use | The degree to which a system is easy to start using without upfront configuration. | https://banes-lab.com/json/records/lexicon/ease-of-initial-use | https://banes-lab.com/records/lexicon/ease-of-initial-use.md | 4048 | 597823e16898f30ecedc0a1a4724788b32017c94fd6a525986d6a8eb75fdf885 |
| lexicon:feature-exposure | quality-attribute | Feature Exposure | The degree to which functionality is made accessible, which broadens capability but enlarges the attack surface. | https://banes-lab.com/json/records/lexicon/feature-exposure | https://banes-lab.com/records/lexicon/feature-exposure.md | 4121 | 2241dcb19c2e977a96bbafa791d23f336ca8205764da8997319338bbf25727f0 |
| lexicon:formatting-flexibility | quality-attribute | Formatting Flexibility | The degree of latitude to present output in varied formats, constrained when encoding must be strict. | https://banes-lab.com/json/records/lexicon/formatting-flexibility | https://banes-lab.com/records/lexicon/formatting-flexibility.md | 4034 | 0f96850d5c6140203b0bba55eff5fb721fdfaa4499632d0009af2b71371f0a1f |
| lexicon:input-flexibility | quality-attribute | Input Flexibility | The degree to which a system accepts varied or loosely-structured input, in tension with strict validation. | https://banes-lab.com/json/records/lexicon/input-flexibility | https://banes-lab.com/records/lexicon/input-flexibility.md | 4020 | 6dcdea817bafafe758259edd429be0f331facccb266ada38bbe255d316100c53 |
| lexicon:key-operations | quality-attribute | Key Operations | The degree of operational burden imposed by generating, rotating, and safeguarding cryptographic keys. | https://banes-lab.com/json/records/lexicon/key-operations | https://banes-lab.com/records/lexicon/key-operations.md | 4003 | 7354971647a952d5e98992185006bdd451464e8ac043e49ac9d4438f2922c0e6 |
| lexicon:latency-complexity | quality-attribute | Latency/Complexity | The degree of added latency and complexity introduced by verifying every request rather than trusting a perimeter. | https://banes-lab.com/json/records/lexicon/latency-complexity | https://banes-lab.com/records/lexicon/latency-complexity.md | 4111 | af220c2000837122c20913319af4f192182e71eaa427de5838085827241fb770 |
| lexicon:operational-convenience | quality-attribute | Operational Convenience | The degree to which broad access makes day-to-day operations easier, in tension with least privilege. | https://banes-lab.com/json/records/lexicon/operational-convenience | https://banes-lab.com/records/lexicon/operational-convenience.md | 4063 | 26a9c046111dbd67868fbd22a094b7c4c6ac4777ff8bdcfa97626384ac52be01 |
| lexicon:pipeline-complexity | quality-attribute | Pipeline Complexity | The degree of intricacy added to a delivery pipeline by embedding continuous checks within it. | https://banes-lab.com/json/records/lexicon/pipeline-complexity | https://banes-lab.com/records/lexicon/pipeline-complexity.md | 4100 | 3a4b2e4447eb0026104f88adc0910bc77d0b3a4f6e4161830530e06b71d4405d |
| lexicon:policy-maintenance | activity | Policy Maintenance | The activity of keeping codified policies correct and current as requirements evolve. | https://banes-lab.com/json/records/lexicon/policy-maintenance | https://banes-lab.com/records/lexicon/policy-maintenance.md | 3963 | 063cefe1464510ff4fa6fab79203ab418555c2af7519d789f105970f2bad7c9d |
| lexicon:role-explosion | quality-attribute | Role Explosion | The degree to which roles proliferate into many narrow definitions as access requirements grow. | https://banes-lab.com/json/records/lexicon/role-explosion | https://banes-lab.com/records/lexicon/role-explosion.md | 4033 | 099a02eb82c20d7e25d320adc4b6ccb741e94d55d29c557f661729ab75212731 |
| lexicon:speed | quality-attribute | Speed | The degree to which delivery proceeds rapidly, in tension with the caution that managing risk requires. | https://banes-lab.com/json/records/lexicon/speed | https://banes-lab.com/records/lexicon/speed.md | 3853 | 2d9fda1c783897ed36044e0e721c388fd7310ad4597e200cbb5d2780400e9e33 |
| lexicon:team-velocity | metric | Team Velocity | The rate at which a team delivers completed work, which governance overhead can slow. | https://banes-lab.com/json/records/lexicon/team-velocity | https://banes-lab.com/records/lexicon/team-velocity.md | 3781 | 2ddad5a65b038ebe0140bfdf212b1f26fc9058a2069611cfd12e4213d34ede6d |
| lexicon:usability | quality-attribute | Usability | The ease with which users can accomplish their goals with a system. | https://banes-lab.com/json/records/lexicon/usability | https://banes-lab.com/records/lexicon/usability.md | 3853 | 0a46c89f1c1ea184745b71619f8833ccabced7de6169d8ee464f8920f8dfb2a4 |
| lexicon:user-convenience | quality-attribute | User Convenience | The degree to which a system minimizes friction and effort for its users. | https://banes-lab.com/json/records/lexicon/user-convenience | https://banes-lab.com/records/lexicon/user-convenience.md | 3977 | a480929103ebfe3b2b1b6376b25884d8c4396a06a2530c4cafc913be1e49ae95 |
| lexicon:remove-secret-from-code | technique | Remove Secret from Code | A technique for deleting a credential from source and history and reading it from a secret store instead. | https://banes-lab.com/json/records/lexicon/remove-secret-from-code | https://banes-lab.com/records/lexicon/remove-secret-from-code.md | 3109 | 98a56a028584cc504d4cd5f9804bb3ffb0c1efe93b3e76019ca7e8f7f0316262 |
| lexicon:secret-rotation | technique | Secret Rotation | A technique for replacing credentials on a schedule and after any exposure, so a leaked secret stops working. | https://banes-lab.com/json/records/lexicon/secret-rotation | https://banes-lab.com/records/lexicon/secret-rotation.md | 4055 | 5ba7dfe94fc0ed534d936a4c343960d61beadc5d9ca122dace9294894798a39f |
| lexicon:least-privilege-credential | technique | Least-Privilege Credential | A technique for issuing each caller a credential that grants only the operations it performs. | https://banes-lab.com/json/records/lexicon/least-privilege-credential | https://banes-lab.com/records/lexicon/least-privilege-credential.md | 3983 | e9d85533ecb77e3c233dd62f361aac14391e4a132a70676bbcdddc57d976123e |
| lexicon:centralize-policy | technique | Centralize Policy | A technique for evaluating every authorization decision through one policy model instead of scattered checks. | https://banes-lab.com/json/records/lexicon/centralize-policy | https://banes-lab.com/records/lexicon/centralize-policy.md | 4503 | 6f8e34afce2546d93c753077236499605fe64b4bd6c8537bd3f76c300878e7a2 |
| lexicon:server-side-enforcement | technique | Server-Side Enforcement | A technique for enforcing every security rule on the server, whatever the client checks. | https://banes-lab.com/json/records/lexicon/server-side-enforcement | https://banes-lab.com/records/lexicon/server-side-enforcement.md | 3082 | a9461426294c9899ba595f1399807300b824f45c73d82767f369d386af65aa9a |
| lexicon:penetration-testing | technique | Penetration Testing | A technique for attacking a system under agreement to find the paths that bypass its controls. | https://banes-lab.com/json/records/lexicon/penetration-testing | https://banes-lab.com/records/lexicon/penetration-testing.md | 3102 | b49c53a864d023a3c6101ec82cb1315c632faf99f4c82b4703a484b7bf22b558 |
| lexicon:authorization-tests | technique | Authorization Tests | A technique for testing each protected operation with permitted and refused identities. | https://banes-lab.com/json/records/lexicon/authorization-tests | https://banes-lab.com/records/lexicon/authorization-tests.md | 3654 | 8eb820f3a9b72abc13422c7bd6ed731f70a916cd449148327764f696bd6a0e2e |
| lexicon:field-redaction | technique | Field Redaction | A technique for removing or masking sensitive fields before data is logged, exported or displayed. | https://banes-lab.com/json/records/lexicon/field-redaction | https://banes-lab.com/records/lexicon/field-redaction.md | 3095 | 1a04b7018b7ac700a28bb028e869edae8dcf4c8cbff0a99c6b0bae2bed54d960 |
| lexicon:purpose-binding | technique | Purpose Binding | A technique for tagging personal data with the purpose it was collected for and refusing uses outside it. | https://banes-lab.com/json/records/lexicon/purpose-binding | https://banes-lab.com/records/lexicon/purpose-binding.md | 4016 | c4b5d1bcba22b5b2a45320e345571d5d761beba2c4135ce04d316d6ce3c46016 |
| lexicon:retention-policy | technique | Retention Policy | A technique for declaring how long each class of data is kept and deleting it when the period ends. | https://banes-lab.com/json/records/lexicon/retention-policy | https://banes-lab.com/records/lexicon/retention-policy.md | 4044 | fe0efc1d5d0b2ed49d78938b2058cc7627f4983178649c4acf6b8f84a625ff28 |
| lexicon:repository-secret-scan | technique | Repository Secret Scan | A technique for scanning source and history for credentials before a change is accepted. | https://banes-lab.com/json/records/lexicon/repository-secret-scan | https://banes-lab.com/records/lexicon/repository-secret-scan.md | 3023 | 4d56d8839543422a467973cdf7fe04351b768d650641f926a089a9d48ac93330 |
| lexicon:default-deny | technique | Default Deny | A technique for refusing every access that no rule explicitly allows. | https://banes-lab.com/json/records/lexicon/default-deny | https://banes-lab.com/records/lexicon/default-deny.md | 3965 | 31992beb3c324e8c9e6bbfe3073dae4003e5c6b4981214d5d71c9c25028e5497 |
| lexicon:sandboxing | technique | Sandboxing | A technique for running untrusted code with only the resources and permissions it is granted. | https://banes-lab.com/json/records/lexicon/sandboxing | https://banes-lab.com/records/lexicon/sandboxing.md | 3217 | a89c067f730ab68c9cc029cc783e7dd5ac19296231dc2c8a94a708511f0ed667 |
| lexicon:network-segmentation | technique | Network Segmentation | A technique for dividing a network into zones whose traffic between them passes declared controls. | https://banes-lab.com/json/records/lexicon/network-segmentation | https://banes-lab.com/records/lexicon/network-segmentation.md | 3251 | cac62d052480372f5d7285ddc41833a3c0212a8d0fc4c5f26c0f192d133c72aa |
| lexicon:central-database-bottleneck | anti-pattern | Central Database Bottleneck | Funneling all state through one shared database that becomes the system's scaling bottleneck. | https://banes-lab.com/json/records/lexicon/central-database-bottleneck | https://banes-lab.com/records/lexicon/central-database-bottleneck.md | 3768 | cdb97cc53d7c72a75b8be4655af90221b4f64268cc11d9cfe242b5fcfae18a0e |
| lexicon:layer-leakage | anti-pattern | Layer Leakage | Letting an inner layer depend on an outer one, violating the direction of the dependency rule. | https://banes-lab.com/json/records/lexicon/layer-leakage | https://banes-lab.com/records/lexicon/layer-leakage.md | 3693 | 98e35668a8cfe15c9dbd27763b8f75669decd95e98796d5281d2ff5cf748ed2d |
| lexicon:layer-skipping | anti-pattern | Layer Skipping | Bypassing intermediate layers to call a distant layer directly, undermining the layering. | https://banes-lab.com/json/records/lexicon/layer-skipping | https://banes-lab.com/records/lexicon/layer-skipping.md | 3717 | cc7f9239c6fdcf4f1661a144e456878d569ebfdf4aca6365de5373ddc1ccdbec |
| lexicon:monolithic-transform-function | anti-pattern | Monolithic Transform Function | Doing all processing in one large transform instead of a series of composable filter stages. | https://banes-lab.com/json/records/lexicon/monolithic-transform-function | https://banes-lab.com/records/lexicon/monolithic-transform-function.md | 3765 | 078f3c43abfaed5ddaa9efb42091fbd3bc5393be78c403f80713308f9227fdb2 |
| lexicon:package-by-technical-layer-only | anti-pattern | Package by Technical Layer Only | Organizing code by technical layer alone, scattering each feature across many packages. | https://banes-lab.com/json/records/lexicon/package-by-technical-layer-only | https://banes-lab.com/records/lexicon/package-by-technical-layer-only.md | 3843 | e2ca1240fb3380030d4908ad9bbf2aae27b3d8c85b28535c38fd3228d97f9c26 |
| lexicon:shared-monolithic-application | anti-pattern | Shared Monolithic Application | Building one large shared application instead of composing independently-governed services. | https://banes-lab.com/json/records/lexicon/shared-monolithic-application | https://banes-lab.com/records/lexicon/shared-monolithic-application.md | 3969 | 0ddd5741f4a4c698849e403a4f39e52d4eceabe42e812a8fd6767f0e2f85ead3 |
| lexicon:contract-governed-service-reuse | capability | Contract-Governed Service Reuse | The ability to reuse services across an enterprise through well-defined contracts. | https://banes-lab.com/json/records/lexicon/contract-governed-service-reuse | https://banes-lab.com/records/lexicon/contract-governed-service-reuse.md | 3439 | cdfd8d726611a7fef7d354dec4dcd67e7145c3eccebf2938f733dfa78f9aef07 |
| lexicon:database-bottleneck-removal | capability | Database-Bottleneck Removal | The ability to eliminate the shared-database bottleneck by holding state in distributed memory. | https://banes-lab.com/json/records/lexicon/database-bottleneck-removal | https://banes-lab.com/records/lexicon/database-bottleneck-removal.md | 3401 | 95cb5c82e84c31b16be76960e7e099a8be225d73d26e88e83d54d2fe96acc97a |
| lexicon:decentralized-ownership | capability | Decentralized Ownership | The ability for separate teams to own, deploy and evolve their services independently. | https://banes-lab.com/json/records/lexicon/decentralized-ownership | https://banes-lab.com/records/lexicon/decentralized-ownership.md | 3311 | 8b89a2ebee0b640fa2fdd298bed68ca706f8715d3896f404f4d80141a8498a6a |
| lexicon:external-system-isolation | capability | External System Isolation | The ability to isolate the core from external systems behind adapter boundaries. | https://banes-lab.com/json/records/lexicon/external-system-isolation | https://banes-lab.com/records/lexicon/external-system-isolation.md | 3898 | b2df72b446928fd027a9e7a575899f342a55733fb40d13d00f5a6299d4efde4f |
| lexicon:framework-independence | capability | Framework Independence | The ability to keep business rules independent of any particular framework. | https://banes-lab.com/json/records/lexicon/framework-independence | https://banes-lab.com/records/lexicon/framework-independence.md | 3311 | a800fb9e71a73740737c786beff1526e78b6ff1ca3c30891b8575b7b9a6f59bb |
| lexicon:independent-stage-testing | capability | Independent Stage Testing | The ability to test each filter stage in isolation from the rest of the pipeline. | https://banes-lab.com/json/records/lexicon/independent-stage-testing | https://banes-lab.com/records/lexicon/independent-stage-testing.md | 3849 | f0127c5052d79bad15121f252fc2b9b7fcc0220184ec668e264fb7f3bbaaa1ce |
| lexicon:infrastructure-independence | capability | Infrastructure Independence | The ability to keep the core independent of the infrastructure it runs on. | https://banes-lab.com/json/records/lexicon/infrastructure-independence | https://banes-lab.com/records/lexicon/infrastructure-independence.md | 3360 | 22548c83f056def29c7ad15855c2d1554fc0eaa8b17d34e00d9bfe63a80ce9e5 |
| lexicon:locality-of-change | capability | Locality of Change | The ability to make a feature's changes in one place because its code is grouped together. | https://banes-lab.com/json/records/lexicon/locality-of-change | https://banes-lab.com/records/lexicon/locality-of-change.md | 3285 | 68198e02ec0416e736fe1b9426cd056550c29f53da520547c4a15c41c4f41adb |
| lexicon:reorderable-stages | capability | Reorderable Stages | The ability to reorder or recombine independent processing stages. | https://banes-lab.com/json/records/lexicon/reorderable-stages | https://banes-lab.com/records/lexicon/reorderable-stages.md | 3261 | 483b4bd503e5847224e470868a057583c1990cb3c3e5271e4901e3f5c9a96365 |
| lexicon:structured-code-organization | capability | Structured Code Organization | The ability to organize code predictably by assigning each responsibility to a layer. | https://banes-lab.com/json/records/lexicon/structured-code-organization | https://banes-lab.com/records/lexicon/structured-code-organization.md | 3315 | 58c3ff342e9c42037264b1be31cef120163afef26742aaf4152caa7b80522608 |
| lexicon:transactional-simplicity | capability | Transactional Simplicity | The ability to use straightforward local transactions when all state lives in one process. | https://banes-lab.com/json/records/lexicon/transactional-simplicity | https://banes-lab.com/records/lexicon/transactional-simplicity.md | 3279 | 484f8fb5748d1b11d9e034c672397d5eea59a11a670978f664e62f1e685c16c4 |
| lexicon:adapters | mechanism | Adapters | Components that translate between a core's ports and the specific external technologies behind them. | https://banes-lab.com/json/records/lexicon/adapters | https://banes-lab.com/records/lexicon/adapters.md | 3733 | 4b1246d1cbf2837d18aaf4633874b8e0004429222837041815f8108f85b8e442 |
| lexicon:boundaries | constraint | Boundaries | The requirement that clear boundaries separate the concentric layers of the system. | https://banes-lab.com/json/records/lexicon/boundaries | https://banes-lab.com/records/lexicon/boundaries.md | 3692 | 53b8d32efedd24b1eeb7aa8717ea0d2cf54e6c92f0403bfea34fa1aaa042908c |
| lexicon:component-boundaries | constraint | Component Boundaries | The requirement that each component expose a well-defined boundary and interface. | https://banes-lab.com/json/records/lexicon/component-boundaries | https://banes-lab.com/records/lexicon/component-boundaries.md | 3663 | 1a4c63191dc87e00de3b84e5546c0bc4d66a47fa297645854db5656615216ee4 |
| lexicon:dependency-rule | constraint | Dependency Rule | The requirement that source-code dependencies point only inward, toward higher-level policy. | https://banes-lab.com/json/records/lexicon/dependency-rule | https://banes-lab.com/records/lexicon/dependency-rule.md | 3206 | e4b517bc0c699b052113d607a726ea5215eca1ae24122f9469b3043054ccc99c |
| lexicon:domain-core | constraint | Domain Core | The requirement that pure domain logic occupy the core, isolated from external concerns. | https://banes-lab.com/json/records/lexicon/domain-core | https://banes-lab.com/records/lexicon/domain-core.md | 3781 | da81cf6eef8f1de957788697653f38f4f761534567a0dedb283b0dfad280176b |
| lexicon:layer-separation | constraint | Layer Separation | The requirement that responsibilities be divided into distinct, ordered layers. | https://banes-lab.com/json/records/lexicon/layer-separation | https://banes-lab.com/records/lexicon/layer-separation.md | 3132 | 0ca404a2d537f8e4b0e5b88435816b0b1a7d05bbe2f73038f39e1928179080f0 |
| lexicon:ports | constraint | Ports | The requirement that the core define abstract interface points through which all external interaction passes. | https://banes-lab.com/json/records/lexicon/ports | https://banes-lab.com/records/lexicon/ports.md | 3771 | 26f328d4f7080c3bf134c45e5e1909288516d72ad9f419cce8814d5b11571582 |
| lexicon:replicated-in-memory-state | constraint | Replicated In-Memory State | The requirement that application state be kept in replicated in-memory grids rather than a central store. | https://banes-lab.com/json/records/lexicon/replicated-in-memory-state | https://banes-lab.com/records/lexicon/replicated-in-memory-state.md | 3298 | db87b4662324c0b20dd0a873ce34eab707ce42686b2082c3c150e6e23939c328 |
| lexicon:unified-deployment-boundary | constraint | Unified Deployment Boundary | The requirement that the whole application build and deploy as one unit. | https://banes-lab.com/json/records/lexicon/unified-deployment-boundary | https://banes-lab.com/records/lexicon/unified-deployment-boundary.md | 3339 | 5fc222a8ec2687d406c63913e4dfbcfba48c01142c7cfadfbcb2d387d0d8fe75 |
| lexicon:uniform-stage-interface | constraint | Uniform Stage Interface | The requirement that every stage share one interface so stages can be composed freely. | https://banes-lab.com/json/records/lexicon/uniform-stage-interface | https://banes-lab.com/records/lexicon/uniform-stage-interface.md | 3252 | 384a927677931c8127c1a2083ad0112aa558c8cb8123feaf6c1b606a394d9ce5 |
| lexicon:use-cases | constraint | Use Cases | The requirement that application operations be captured as explicit use cases in their own layer. | https://banes-lab.com/json/records/lexicon/use-cases | https://banes-lab.com/records/lexicon/use-cases.md | 4170 | 31f0d00892787bc225c18ec384c4a6c0d907086475de56448a9b8f2c67f063b4 |
| lexicon:anemic-layers | quality-attribute | Anemic Layers | The degree to which strict layering produces thin pass-through layers that add indirection without logic. | https://banes-lab.com/json/records/lexicon/anemic-layers | https://banes-lab.com/records/lexicon/anemic-layers.md | 4035 | 822756a08053b2099f099ca4753e18a0db91950fcd2e38252c9e7f3c78b99848 |
| lexicon:end-to-end-traceability | quality-attribute | End-to-End Traceability | The degree to which decomposing flow into independent filters makes tracing a request end to end harder. | https://banes-lab.com/json/records/lexicon/end-to-end-traceability | https://banes-lab.com/records/lexicon/end-to-end-traceability.md | 4079 | 41adafb7113f9e2300c0b26cc9e9a6206d040350f57e4d44b67b3142cd44a635 |
| lexicon:feature-cohesion | quality-attribute | Feature Cohesion | The degree to which all code serving one feature is grouped together rather than scattered by layer. | https://banes-lab.com/json/records/lexicon/feature-cohesion | https://banes-lab.com/records/lexicon/feature-cohesion.md | 3280 | f25738a93fc39f3d5e3e5d8da2cacc1ebae14a637af3e148405ba9f986a9b917 |
| lexicon:independent-scaling | quality-attribute | Independent Scaling | The degree to which a single deployable unit prevents scaling parts of the system independently. | https://banes-lab.com/json/records/lexicon/independent-scaling | https://banes-lab.com/records/lexicon/independent-scaling.md | 4543 | fd366671c41f0ffa04c72eed6b00a1a7d640e612f3e64e4ac09cc4af2739902f |
| lexicon:initial-complexity | quality-attribute | Initial Complexity | The degree of upfront structural complexity introduced by defining ports and adapters. | https://banes-lab.com/json/records/lexicon/initial-complexity | https://banes-lab.com/records/lexicon/initial-complexity.md | 5251 | cd6dd60e368402b7dbf052cb2c299f5f0139929681abc165130a824796635456 |
| lexicon:integration-overhead | quality-attribute | Integration Overhead | The degree of effort required to wire independently-developed components together. | https://banes-lab.com/json/records/lexicon/integration-overhead | https://banes-lab.com/records/lexicon/integration-overhead.md | 4195 | e6515231e1ea35e7bf0e07d408e2548d2e952daae8a073f25626361adf6fd96b |
| lexicon:operational-simplicity | quality-attribute | Operational Simplicity | The degree to which a single deployable unit keeps building, deploying, and operating simple. | https://banes-lab.com/json/records/lexicon/operational-simplicity | https://banes-lab.com/records/lexicon/operational-simplicity.md | 3329 | afaebb615ecdc384f49ee25474822bf154095a3a04c8d22cb3235ab8f085b700 |
| lexicon:shared-technical-concerns | quality-attribute | Shared Technical Concerns | The degree to which grouping by feature complicates sharing cross-cutting technical code. | https://banes-lab.com/json/records/lexicon/shared-technical-concerns | https://banes-lab.com/records/lexicon/shared-technical-concerns.md | 4127 | 045d0e9db5429200d2848a00a5b14411eb8a9fc3a24af4b82086ce7a7cbe58ee |
| lexicon:introduce-port | technique | Introduce Port | A technique for declaring an interface owned by the core that names what it needs from the outside world. | https://banes-lab.com/json/records/lexicon/introduce-port | https://banes-lab.com/records/lexicon/introduce-port.md | 11028 | 1644ab0a0ce28bed89f99a50aa3a60d821ddcd0f2e04983390e82b86efaa8541 |
| lexicon:extract-adapter | technique | Extract Adapter | A technique for moving the code that talks to a framework, vendor or protocol into an adapter behind a port. | https://banes-lab.com/json/records/lexicon/extract-adapter | https://banes-lab.com/records/lexicon/extract-adapter.md | 12968 | fb601e6a80bdb047462737064525c89824d3d58699c5130fd0a74ef08b40e455 |
| lexicon:move-framework-outward | technique | Move Framework Outward | A technique for removing framework types and annotations from the core and confining them to adapters. | https://banes-lab.com/json/records/lexicon/move-framework-outward | https://banes-lab.com/records/lexicon/move-framework-outward.md | 4124 | 9456600a1e9cacc6d1d65b37b84c03860ee42ace12d7a708d24d7262ca8914a5 |
| lexicon:repackage-by-feature | technique | Repackage by Feature | A technique for moving the code of one feature from technical-layer folders into one folder of its own. | https://banes-lab.com/json/records/lexicon/repackage-by-feature | https://banes-lab.com/records/lexicon/repackage-by-feature.md | 3289 | 992377a26fad0f43768e02502580eec4a1dcc5cd9f8f1fb826b56f271353701e |
| lexicon:coordination-surface | artifact | Coordination Surface | A formal definition of a file that parties read and write to coordinate work, carrying a declared key and scope in its header and records each owned by one writer. | https://banes-lab.com/json/records/lexicon/coordination-surface | https://banes-lab.com/records/lexicon/coordination-surface.md | 4796 | 957a8a8033ee9a718cd9bcf91ac3131d8469d5ffd86c31b6860563dfd13a6ca8 |
| lexicon:coordination-record | artifact | Coordination Record | A formal definition of one addressable claim inside a coordination surface, carrying its schema fields, its edges, an allocated id, a declared subject and the one writer it names. | https://banes-lab.com/json/records/lexicon/coordination-record | https://banes-lab.com/records/lexicon/coordination-record.md | 4073 | c76cd6b55faf7579f3763b387147c20a865dd0b3120f7f3e1701b32e5e44ef0d |
| lexicon:outcome-surface | artifact | Outcome Surface | A formal definition of a surface that carries one product authored jointly, such as a contract or a class statement, with no per-party unit an ownership fence could range over. | https://banes-lab.com/json/records/lexicon/outcome-surface | https://banes-lab.com/records/lexicon/outcome-surface.md | 4162 | 76f9576130e8d36beab6ebd485fb2be4bb7b3d36dbabe6392c09f03244fbb5eb |
| lexicon:participant | artifact | Participant | A formal definition of a reader that owns surfaces and an inbox, receives both, and waits between turns instead of ending. | https://banes-lab.com/json/records/lexicon/participant | https://banes-lab.com/records/lexicon/participant.md | 2076 | 49f4259e6957d7a51f8d871f4f7fa1df638701b85ca05233a6637526446c845c |
| lexicon:bounded-reader | artifact | Bounded Reader | A formal definition of a reader handed a task and whatever its host injects, never a coordination surface, which ends by returning its result. | https://banes-lab.com/json/records/lexicon/bounded-reader | https://banes-lab.com/records/lexicon/bounded-reader.md | 4054 | 605d2110eaabeff80ddc31b996a33d3b152ca94846137706dff6a240a9021573 |
| lexicon:host-projection | artifact | Host Projection | Descriptive data about the coordination graph that a host injects into every bounded reader's context, the only channel through which such a reader learns anything about the surfaces. | https://banes-lab.com/json/records/lexicon/host-projection | https://banes-lab.com/records/lexicon/host-projection.md | 4064 | a730c830e10c04db0c6a177887aa4d818f2f0a6dfb3b2778a106c71730a3fe33 |
| lexicon:venue | artifact | Venue | A formal definition of a surface opened for one discussion, which declares its own exit condition and moves to the archive once the outcome it produced has landed. | https://banes-lab.com/json/records/lexicon/venue | https://banes-lab.com/records/lexicon/venue.md | 2078 | f896991e1472c4c89db411f885830bee9057e3b8e9e701ff7424bc01d7032643 |
| lexicon:accumulator | artifact | Accumulator | A formal definition of a surface that receives what a record extracts before the record is deleted, so a deletion loses nothing a later reader needs. | https://banes-lab.com/json/records/lexicon/accumulator | https://banes-lab.com/records/lexicon/accumulator.md | 2028 | 2d33b39a004d8e76c19be3e8555cf14af16390f1066c610357b830dd19f7b0e0 |
| lexicon:retention | artifact | Retention | A formal definition of the lifetime axis that states what ends a piece of content, whether nothing, a newer version of itself, the completion of what it asked for, or its producer regenerating the whole surface. | https://banes-lab.com/json/records/lexicon/retention | https://banes-lab.com/records/lexicon/retention.md | 4075 | ae237d4c7e6a0dd2fcbdf10ca0a8e18deaf973ecce07b5949db135db7a44c0d7 |
| lexicon:mutability | artifact | Mutability | A formal definition of the lifetime axis that states whether a landed statement may be rewritten, and by whom, its own writer or nobody. | https://banes-lab.com/json/records/lexicon/mutability | https://banes-lab.com/records/lexicon/mutability.md | 4487 | eafd2180ac939b03a2f0348b173c9adb3428a5cae231a1ff7d93e17e7987a09a |
| lexicon:removal-authority | artifact | Removal Authority | A formal definition of the lifetime axis that states who may take content out, whether nobody at any point, its writer, the party that discharged it, or the mechanism that regenerates it. | https://banes-lab.com/json/records/lexicon/removal-authority | https://banes-lab.com/records/lexicon/removal-authority.md | 4121 | 58b8d28f7ea1b5adcb1b267cb5a6d1b6d94f89992efce9fcfef8437193fcf6ca |
| lexicon:write-scope | artifact | Write Scope | A formal definition of the set of paths a run declares it may write, compared by declaration before the run begins to decide whether two runs collide. | https://banes-lab.com/json/records/lexicon/write-scope | https://banes-lab.com/records/lexicon/write-scope.md | 4507 | fa2afec6cf0015843ce7aa754d83d509b2fc2c80bdecdd7b4df8701e3e4ed55b |
| lexicon:read-population | artifact | Read Population | A formal definition of the set a run read and publishes with its result, which a later caller tests to decide whether that result answers its own question. | https://banes-lab.com/json/records/lexicon/read-population | https://banes-lab.com/records/lexicon/read-population.md | 4801 | 73ca622e7b894dc6c69eff8d8fe05caa5dd4ea657f4b7a3fa636e2a30a68d590 |
| lexicon:joiner | artifact | Joiner | A formal definition of a caller that reads a live run's published result and its standing instead of starting a run of its own, with an empty write set. | https://banes-lab.com/json/records/lexicon/joiner | https://banes-lab.com/records/lexicon/joiner.md | 4027 | 32288139e1cac34f74a27ed7d0acc3b138dacf99e05403a13a42bea0ba5143cb |
| lexicon:liveness-witness | mechanism | Liveness Witness | A facility that answers whether a process is still running by checking that the process is present, so its absence proves death while its presence proves nothing. | https://banes-lab.com/json/records/lexicon/liveness-witness | https://banes-lab.com/records/lexicon/liveness-witness.md | 3605 | f654aab42ae841a63a99bd61d825c14619a96001cb371934696d65e4747a765c |
| lexicon:distinguished-copy | artifact | Distinguished Copy | A formal definition of the one copy of a fact that every other copy derives from, or the one copy a mechanism resolves, which gives a set of copies its direction. | https://banes-lab.com/json/records/lexicon/distinguished-copy | https://banes-lab.com/records/lexicon/distinguished-copy.md | 3707 | 3262e11df6df896579646bedb6321c0fe1813b74ac76bdeff300d641677a0b78 |
| lexicon:derivation-period | artifact | Derivation Period | A formal definition of how often a derivation edge runs, on every read, between stores or once at creation, which decides whether a copy is stale or is a record. | https://banes-lab.com/json/records/lexicon/derivation-period | https://banes-lab.com/records/lexicon/derivation-period.md | 4150 | 5c5160eded878c5e5c8274a42afd02c5f16845f00b2335aa11b9c2f4dee10aae |
| lexicon:carrier-field | artifact | Carrier Field | A formal definition of a field whose consumers are mechanisms and whose value is drawn from a closed set or is an identifier. | https://banes-lab.com/json/records/lexicon/carrier-field | https://banes-lab.com/records/lexicon/carrier-field.md | 4015 | 84538b9cf7d55cd79ef001a490e8a063be2089000b864c74ca4874972c3537df |
| lexicon:payload-field | artifact | Payload Field | A formal definition of a field whose only consumer is a reader and which no parser reaches without a heuristic. | https://banes-lab.com/json/records/lexicon/payload-field | https://banes-lab.com/records/lexicon/payload-field.md | 4059 | 1f9edea8338823ac38154c1b0c56034c1008d455907b924bd4a80b5c5b029d7b |
| lexicon:concern-partition | artifact | Concern Partition | A formal definition of how a body of work divides into concerns, derived from a coupling relation that joins two surfaces when a change to one forces a change to the other. | https://banes-lab.com/json/records/lexicon/concern-partition | https://banes-lab.com/records/lexicon/concern-partition.md | 3588 | 0be14da363196e324015fa9fd9b99397206508fdc1b79787e3653926905c235b |
| lexicon:fan-in | metric | Fan-In | A measure of how many parties' claims rest on one surface, read from who authored each claim, whom it addressed and which surfaces it cites. | https://banes-lab.com/json/records/lexicon/fan-in | https://banes-lab.com/records/lexicon/fan-in.md | 3963 | a8e928a8d478acf6256ad0db3888757dd4e8233af1853e07d3fea651e8ba5474 |
| lexicon:acknowledger | artifact | Acknowledger | A formal definition of the party a record names to close it when its satisfaction is a judgment, required where no artifact resolves the record and forbidden where one does. | https://banes-lab.com/json/records/lexicon/acknowledger | https://banes-lab.com/records/lexicon/acknowledger.md | 4042 | f16a05b206719f1564028a3bb3a0fe0a0f705907165c563a1c3fa4910698d7aa |
| lexicon:stall-bound | constraint | Stall Bound | A rule or precondition that a record satisfied by judgment and left unacknowledged past a declared number of rounds is a finding, a bound on its lifetime rather than its size. | https://banes-lab.com/json/records/lexicon/stall-bound | https://banes-lab.com/records/lexicon/stall-bound.md | 2126 | f4d29a50acee4d9dd70301ea663dab9bff1efb3e6d5839548b93fea4ce9dff39 |
| lexicon:deferred-setting | artifact | Deferred Setting | A formal definition of a host setting declared as given later, which blocks every check that depends on it until it is given, while an absent setting turns those checks off. | https://banes-lab.com/json/records/lexicon/deferred-setting | https://banes-lab.com/records/lexicon/deferred-setting.md | 2152 | fef9059d8629c18da515d0e2264019d4f7b377a87360fad9e9c00e6bd1019be9 |
| lexicon:traceable-guarantee | capability | Traceable Guarantee | The ability to trace every guarantee a topology offers back to a stated property and the mechanism that would object if it stopped holding. | https://banes-lab.com/json/records/lexicon/traceable-guarantee | https://banes-lab.com/records/lexicon/traceable-guarantee.md | 7924 | e474c3d780e5a1d70f5213391dbf667e07f790cab76a9fcbe0313043599bb8a2 |
| lexicon:rederivation-detection | capability | Rederivation Detection | The ability to catch a record written a second time about a subject another record already holds. | https://banes-lab.com/json/records/lexicon/rederivation-detection | https://banes-lab.com/records/lexicon/rederivation-detection.md | 3619 | d0bc749dc7c76411f0273c1ea3a6ae63c39820901bc93b0479c765faae6acf17 |
| lexicon:governed-removal | capability | Governed Removal | The ability to remove content only where its declared lifetime names the party or mechanism allowed to remove it. | https://banes-lab.com/json/records/lexicon/governed-removal | https://banes-lab.com/records/lexicon/governed-removal.md | 4516 | f04767daef6ab2d35f0e336ad15ba29ce407e1bb342ae1e55d22c4c28117aa60 |
| lexicon:shared-invocation | capability | Shared Invocation | The ability for several callers to share one run of a measurement, each either joining a live run that covers its question or starting one that no live run covers. | https://banes-lab.com/json/records/lexicon/shared-invocation | https://banes-lab.com/records/lexicon/shared-invocation.md | 4860 | e0944249c7dc045b1e1cffef4342bae51f8dffc08bd8d1a8d6749a1dc3a5f7b8 |
| lexicon:name-the-objector | technique | Name the Objector | A technique for naming, for each stated invariant, the party or check that objects when it stops holding. | https://banes-lab.com/json/records/lexicon/name-the-objector | https://banes-lab.com/records/lexicon/name-the-objector.md | 3120 | 0c3ebd4a1522f5465b846461b3e781b680943fa33f9c7a49fe80bc48f4f43c42 |
| lexicon:mark-the-invariant-unheld | technique | Mark the Invariant Unheld | A technique for marking an invariant that nothing enforces as unheld, together with every derivation that rests on it. | https://banes-lab.com/json/records/lexicon/mark-the-invariant-unheld | https://banes-lab.com/records/lexicon/mark-the-invariant-unheld.md | 3155 | 0fb72f415e191908a1a9ee36d4fc86d4c9b0b0bd86330374f6597107c2154a59 |
| lexicon:derive-state-from-edges | technique | Derive State from Edges | A technique for removing a written status field and computing a record's state from the edges that connect it. | https://banes-lab.com/json/records/lexicon/derive-state-from-edges | https://banes-lab.com/records/lexicon/derive-state-from-edges.md | 3584 | 93a45a110cb8df48b6dd766bd417e09766b2e9ef47790a3219944aefe73cb84e |
| lexicon:allocate-identity-once | technique | Allocate Identity Once | A technique for assigning a record its id when it is created and never deriving it again from its location or subject. | https://banes-lab.com/json/records/lexicon/allocate-identity-once | https://banes-lab.com/records/lexicon/allocate-identity-once.md | 3223 | 329037c2514d3573b9dfc4fc0eb7cf2e78602ce9898696870adc8b926ddb8882 |
| lexicon:declare-the-subject-beside-the-id | technique | Declare the Subject Beside the Id | A technique for recording a record's subject as a declared field next to its id, so either can change without breaking the other. | https://banes-lab.com/json/records/lexicon/declare-the-subject-beside-the-id | https://banes-lab.com/records/lexicon/declare-the-subject-beside-the-id.md | 3283 | 354e3ae6141f9ea36dfd20d669b2a7b3dadf832a68a66a346afe8b71c9ac161e |
| lexicon:hold-the-barrier-for-planned-writes | technique | Hold the Barrier for Planned Writes | A technique for taking an exclusive write on a shared surface only after every peer is observed parked. | https://banes-lab.com/json/records/lexicon/hold-the-barrier-for-planned-writes | https://banes-lab.com/records/lexicon/hold-the-barrier-for-planned-writes.md | 3265 | 225c7b396b583416f454efe0093fa67ed4415da5747771398802e09bda112981 |
| lexicon:declare-the-missing-operand | technique | Declare the Missing Operand | A technique for declaring on a jointly authored surface that the one-writer invariant has no operand there. | https://banes-lab.com/json/records/lexicon/declare-the-missing-operand | https://banes-lab.com/records/lexicon/declare-the-missing-operand.md | 3352 | e2bfb92121d85a1a5d3fa0f7cec869f27f1c30b57af3df9fcec1e88a3d11cfd3 |
| lexicon:settle-collisions-by-announcement | technique | Settle Collisions by Announcement | A technique for resolving concurrent work on a jointly authored surface by each party announcing its claim before acting. | https://banes-lab.com/json/records/lexicon/settle-collisions-by-announcement | https://banes-lab.com/records/lexicon/settle-collisions-by-announcement.md | 3390 | 8a1c6fd7404d7925fe7238a85d39643e4a937e6719d48ab94730ce0f0731afee |
| lexicon:refresh-the-projection-in-the-same-change | technique | Refresh the Projection in the Same Change | A technique for updating a projection in the same change that moves the fact it summarizes. | https://banes-lab.com/json/records/lexicon/refresh-the-projection-in-the-same-change | https://banes-lab.com/records/lexicon/refresh-the-projection-in-the-same-change.md | 3307 | df818f8304f402a015b54933e7a2fd236cbd70f8ca4fdfae7e8008562c51fc6f |
| lexicon:check-the-projection-s-shape | technique | Check the Projection's Shape | A technique for checking that a projection holds only the shape its name claims. | https://banes-lab.com/json/records/lexicon/check-the-projection-s-shape | https://banes-lab.com/records/lexicon/check-the-projection-s-shape.md | 3329 | fa2e21590d0b1310b309f9c75373e8a591ecdf69f4e0a0767fe049f0564ddbaa |
| lexicon:generate-the-index-from-the-directory | technique | Generate the Index from the Directory | A technique for producing an index by reading the directory it describes instead of editing entries by hand. | https://banes-lab.com/json/records/lexicon/generate-the-index-from-the-directory | https://banes-lab.com/records/lexicon/generate-the-index-from-the-directory.md | 3613 | bcfa76a10134ddbdca9396bc045e1d050e5da59d5dec9b20137a5243b167b6b7 |
| lexicon:check-both-directions | technique | Check Both Directions | A technique for checking that every index entry resolves to a file and that every file has an entry. | https://banes-lab.com/json/records/lexicon/check-both-directions | https://banes-lab.com/records/lexicon/check-both-directions.md | 3276 | 0424236caea47b6099277372fb00a4539d71e5b7446e9d3166f801b7d2384e79 |
| lexicon:declare-all-three-lifetime-axes | technique | Declare All Three Lifetime Axes | A technique for declaring each surface's lifetime with a value from the closed set of every axis, so no axis is inferred. | https://banes-lab.com/json/records/lexicon/declare-all-three-lifetime-axes | https://banes-lab.com/records/lexicon/declare-all-three-lifetime-axes.md | 3252 | 701066fde52bca05f84f520405c4d2062a5965558c737dcfa753189a6de2cf0b |
| lexicon:declare-the-file-default | technique | Declare the File Default | A technique for stating the lifetime a file's sections take unless a section declares its own. | https://banes-lab.com/json/records/lexicon/declare-the-file-default | https://banes-lab.com/records/lexicon/declare-the-file-default.md | 3287 | 1adeef2c4cd669f76ba8aa45bc85a779abe9de7fc9ecab7f955546972d713fd2 |
| lexicon:declare-each-divergent-section | technique | Declare Each Divergent Section | A technique for declaring the lifetime of every section that lives differently from its file's default. | https://banes-lab.com/json/records/lexicon/declare-each-divergent-section | https://banes-lab.com/records/lexicon/declare-each-divergent-section.md | 3250 | 241a05d4a882e1f7e7b4cce942092ec1b1acd0fc2ebe0e99e6be53f40752c2f5 |
| lexicon:declare-the-write-scope | technique | Declare the Write Scope | A technique for publishing the part of a surface a run writes, so overlapping runs are detected. | https://banes-lab.com/json/records/lexicon/declare-the-write-scope | https://banes-lab.com/records/lexicon/declare-the-write-scope.md | 3285 | 780bae82caf0e5ec72bd43df11d3355a9ec96283f5717a6d96df57bbfaa7447b |
| lexicon:publish-the-read-population | technique | Publish the Read Population | A technique for publishing what a run read, so a later question can tell whether the run's result answers it. | https://banes-lab.com/json/records/lexicon/publish-the-read-population | https://banes-lab.com/records/lexicon/publish-the-read-population.md | 3239 | 4c8d1928d81d3043f7f77fba4504cf86ea75ba6c9553a4b2fbb59f1a51c32f2d |
| lexicon:test-coverage-first | technique | Test Coverage First | A technique for checking whether a live run's scope already covers a question before starting a new run. | https://banes-lab.com/json/records/lexicon/test-coverage-first | https://banes-lab.com/records/lexicon/test-coverage-first.md | 3222 | 4db55bea45c07fb7d2c8201ef9e72fffa88c078c70db7c0c394ae10c5fdc6f2c |
| lexicon:join-by-reading-the-published-result | technique | Join by Reading the Published Result | A technique for waiting on another run by reading the result it publishes instead of attaching to its process. | https://banes-lab.com/json/records/lexicon/join-by-reading-the-published-result | https://banes-lab.com/records/lexicon/join-by-reading-the-published-result.md | 3176 | 7fc07d2606c85eff048cf71641ff3e3f7d4ed80e6d7555694a5acf75fcfe23b1 |
| lexicon:derive-liveness-once | technique | Derive Liveness Once | A technique for computing liveness in one place that every consumer reads. | https://banes-lab.com/json/records/lexicon/derive-liveness-once | https://banes-lab.com/records/lexicon/derive-liveness-once.md | 3146 | 4c824db5674f855c896d663e5b8469077654723e50e1c609bcffeda98aea4fe2 |
| lexicon:witness-first | technique | Witness First | A technique for deciding liveness from a witness the process writes, never from the process being present. | https://banes-lab.com/json/records/lexicon/witness-first | https://banes-lab.com/records/lexicon/witness-first.md | 3070 | e3516e557768a8bcd041c01139c7b9f7884b5e2ef806fd3a810f2c8678aad984 |
| lexicon:window-second | technique | Window Second | A technique for applying a time window to a liveness witness only after the witness is read. | https://banes-lab.com/json/records/lexicon/window-second | https://banes-lab.com/records/lexicon/window-second.md | 3091 | 38a9eb1f28b9787824e1942eaf0f1bb14eebc918180034be8cb7513c49aa8252 |
| lexicon:encode-the-scope-reversibly | technique | Encode the Scope Reversibly | A technique for naming a channel by an encoding of its scope that can be decoded back to the scope. | https://banes-lab.com/json/records/lexicon/encode-the-scope-reversibly | https://banes-lab.com/records/lexicon/encode-the-scope-reversibly.md | 3159 | f7c1f211354ed1b9f3c5404ae4f738fdaa9a845e4da93aca963b28f6c8f8050f |
| lexicon:declare-the-remover | technique | Declare the Remover | A technique for recording which party removes a channel, so every channel has a party that can attribute it. | https://banes-lab.com/json/records/lexicon/declare-the-remover | https://banes-lab.com/records/lexicon/declare-the-remover.md | 3301 | af97a57889f30e27d9362ce038c722c06f0c69f56da5a1cd03173124206f8a66 |
| lexicon:write-the-entry-before-reading-the-set | technique | Write the Entry Before Reading the Set | A technique for writing a run's own entry before reading the set of live runs, so two starters see each other. | https://banes-lab.com/json/records/lexicon/write-the-entry-before-reading-the-set | https://banes-lab.com/records/lexicon/write-the-entry-before-reading-the-set.md | 3269 | 2d185629c4607c7c22bacf6648cd9972cb19dc579c4b28ed3c32332ad4f6eaf6 |
| lexicon:count-distinguished-copies | technique | Count Distinguished Copies | A technique for counting the copies that differ from their source before deciding which way to collapse them. | https://banes-lab.com/json/records/lexicon/count-distinguished-copies | https://banes-lab.com/records/lexicon/count-distinguished-copies.md | 3270 | 35d622ac51e3d511a0778c6c8be3eaac6929a2344b73795cdf33fa7ade4c6cfd |
| lexicon:read-each-period | technique | Read Each Period | A technique for checking, for each copy, whether the edge that produced it runs again or ran once against an earlier state. | https://banes-lab.com/json/records/lexicon/read-each-period | https://banes-lab.com/records/lexicon/read-each-period.md | 3189 | 3dcfa41e6f0fe8ef13f3188f53d6d623bb49f778579c4370e2e5469ba3f1f654 |
| lexicon:repair-the-source | technique | Repair the Source | A technique for fixing a defect at the source every copy derives from instead of in the copies. | https://banes-lab.com/json/records/lexicon/repair-the-source | https://banes-lab.com/records/lexicon/repair-the-source.md | 3130 | 11723fbebba19bfa78fe0d0b1301a509ff1013a5e268bbd6e7993be1279bd541 |
| lexicon:derive-the-partition | technique | Derive the Partition | A technique for deriving the partition of work from the surfaces involved before choosing how many parties take part. | https://banes-lab.com/json/records/lexicon/derive-the-partition | https://banes-lab.com/records/lexicon/derive-the-partition.md | 3184 | 7a350b1dfc2261bb585bcd2c0c6e872b7c8a38d2670f46f47d0ac941b3e899d2 |
| lexicon:count-the-partition-s-concerns | technique | Count the Partition's Concerns | A technique for setting the party count to the number of concerns the derived partition holds. | https://banes-lab.com/json/records/lexicon/count-the-partition-s-concerns | https://banes-lab.com/records/lexicon/count-the-partition-s-concerns.md | 3236 | 3d294800ef3c859b3f394bca9d812e9a5dd4d81e7ddbcec358a66c16a5640691 |
| lexicon:mark-claims-with-their-read-moment | technique | Mark Claims with Their Read Moment | A technique for stamping each claim with the moment its surface was read, so a stale claim is recognized. | https://banes-lab.com/json/records/lexicon/mark-claims-with-their-read-moment | https://banes-lab.com/records/lexicon/mark-claims-with-their-read-moment.md | 3223 | 9e5bf6dc3b7d68ec2e2d757fef7ba55b0ece3a5c91fbb0a5395efc33e72b83d6 |
| lexicon:partition-the-surface | technique | Partition the Surface | A technique for dividing a surface that too many parties reason about into surfaces with fewer readers each. | https://banes-lab.com/json/records/lexicon/partition-the-surface | https://banes-lab.com/records/lexicon/partition-the-surface.md | 3309 | 6f59b616763ac4476dc5925e5f0414c42ddb275bfd00d949c8fa1e99469d2689 |
| lexicon:retain-the-prior-state-in-the-spanning-layer | technique | Retain the Prior State in the Spanning Layer | A technique for keeping the earlier state of content in the layer that spans both states, so a change rule can compare them. | https://banes-lab.com/json/records/lexicon/retain-the-prior-state-in-the-spanning-layer | https://banes-lab.com/records/lexicon/retain-the-prior-state-in-the-spanning-layer.md | 3267 | c08ebf4034afca70ac54d732c3d88dd07318595d83c82511370d97d7e3f0cee3 |
| lexicon:compare-the-two-readings | technique | Compare the Two Readings | A technique for enforcing a change rule by comparing the content before and after the change. | https://banes-lab.com/json/records/lexicon/compare-the-two-readings | https://banes-lab.com/records/lexicon/compare-the-two-readings.md | 3231 | 7a446492a32f64d853aed2f95414635ce339c3b72fe69a213678b518198e1da5 |
| lexicon:type-the-carrier | technique | Type the Carrier | A technique for giving the fields a mechanism reads a resolvable typed form. | https://banes-lab.com/json/records/lexicon/type-the-carrier | https://banes-lab.com/records/lexicon/type-the-carrier.md | 3157 | a6dffca0312e1362b41c6b4f036ccc8e89a350804deb252883aff0eb7806f687 |
| lexicon:leave-the-payload-prose | technique | Leave the Payload Prose | A technique for keeping the fields only people read as prose that no mechanism parses. | https://banes-lab.com/json/records/lexicon/leave-the-payload-prose | https://banes-lab.com/records/lexicon/leave-the-payload-prose.md | 3180 | fe89e3b0dfef657a96545505233c7c472c9189f73ec39b7826dc8dc29ff93271 |
| lexicon:remove-the-restating-payload | technique | Remove the Restating Payload | A technique for deleting payload text that restates what its carrier already answers. | https://banes-lab.com/json/records/lexicon/remove-the-restating-payload | https://banes-lab.com/records/lexicon/remove-the-restating-payload.md | 3254 | 03dcda1a8d55c79a256c6975db47adef7045730a01817fb94bd3b02d7084cf22 |
| lexicon:draw-the-value-from-a-closed-set | technique | Draw the Value from a Closed Set | A technique for making a mandated field take a value from a declared closed set that a consumer can join on. | https://banes-lab.com/json/records/lexicon/draw-the-value-from-a-closed-set | https://banes-lab.com/records/lexicon/draw-the-value-from-a-closed-set.md | 3293 | cad87eb396f22bc2569b55f8b427f0350cfcbf2a14a62841da3c39b4683ed27a |
| lexicon:declare-the-field-for-readers | technique | Declare the Field for Readers | A technique for declaring that a mandated prose field is written for people, so no consumer is assumed to read it. | https://banes-lab.com/json/records/lexicon/declare-the-field-for-readers | https://banes-lab.com/records/lexicon/declare-the-field-for-readers.md | 3362 | 5384012ef7e6d874439736eb1a7687970147e40310848d78493d4a08089b33c4 |
| lexicon:write-the-aggregate-only-from-a-full-run | technique | Write the Aggregate Only from a Full Run | A technique for overwriting an aggregate report only from a run that measured its whole population. | https://banes-lab.com/json/records/lexicon/write-the-aggregate-only-from-a-full-run | https://banes-lab.com/records/lexicon/write-the-aggregate-only-from-a-full-run.md | 3636 | 3243f4cf8b9d9172c158f8fe8efc98d4456a8b54e12ea7decfeac07a266fd2ba |
| lexicon:stream-narrowed-verdicts | technique | Stream Narrowed Verdicts | A technique for returning the verdicts of a narrowed run to its caller instead of writing them as a report. | https://banes-lab.com/json/records/lexicon/stream-narrowed-verdicts | https://banes-lab.com/records/lexicon/stream-narrowed-verdicts.md | 3630 | cab020ee3481f59066934cb186a057c015ddccd7d0517f03145bc79ef167d68a |
| lexicon:keep-one-aggregate | technique | Keep One Aggregate | A technique for holding one aggregate report per subject, with no report named for a scope or caller beside it. | https://banes-lab.com/json/records/lexicon/keep-one-aggregate | https://banes-lab.com/records/lexicon/keep-one-aggregate.md | 3235 | 8a1045d2b5692abfb15252296cf96a6eb7467854c29ebaef7f5cdadac9694406 |
| lexicon:treat-the-statements-as-one-unit | technique | Treat the Statements as One Unit | A technique for treating every statement of one invariant as a single unit that one query ranges over. | https://banes-lab.com/json/records/lexicon/treat-the-statements-as-one-unit | https://banes-lab.com/records/lexicon/treat-the-statements-as-one-unit.md | 3237 | 013fcfea7f7ff06cd793180355365051429276448ce9a67c96bbe0742d57e302 |
| lexicon:re-derive-every-copy-on-change | technique | Re-Derive Every Copy on Change | A technique for regenerating every copy of an invariant from its source whenever the source changes. | https://banes-lab.com/json/records/lexicon/re-derive-every-copy-on-change | https://banes-lab.com/records/lexicon/re-derive-every-copy-on-change.md | 3272 | 76b45b74033f96f672f13b167bdf7c0cfa1d98c89ae725a0720f7ebdd6f40fba |
| lexicon:refuse-and-name-the-cycle | technique | Refuse and Name the Cycle | A technique for refusing to collapse a set of copies with no distinguished member and reporting the cycle by name. | https://banes-lab.com/json/records/lexicon/refuse-and-name-the-cycle | https://banes-lab.com/records/lexicon/refuse-and-name-the-cycle.md | 3226 | 8ce8900c3d8621e3beddb3bb67dfa01b2fdd411e989fe06894436d91dd4fb72d |
| lexicon:archive-the-absorbed-venue | technique | Archive the Absorbed Venue | A technique for moving a closed venue to the archive once its outcome is absorbed, instead of deleting it. | https://banes-lab.com/json/records/lexicon/archive-the-absorbed-venue | https://banes-lab.com/records/lexicon/archive-the-absorbed-venue.md | 3187 | 69e31f040d3785a7cbb6bdc596d345b95043587c0ae0cd10978a6fec0b8fafaf |
| lexicon:unobjected-invariant | anti-pattern | Unobjected Invariant | A defect in which a system relies on a property that nothing would notice losing. | https://banes-lab.com/json/records/lexicon/unobjected-invariant | https://banes-lab.com/records/lexicon/unobjected-invariant.md | 3130 | b4339e508fdbb615c8cb3caf9bb69d863af95714f44d9c4003deb1ef1632c8de |
| lexicon:unreceived-invariant | anti-pattern | Unreceived Invariant | A defect in which an invariant is stated in a surface its bound parties never receive. | https://banes-lab.com/json/records/lexicon/unreceived-invariant | https://banes-lab.com/records/lexicon/unreceived-invariant.md | 3130 | d923837de6dff79871b16264a963c1db43f36f5c22df3ba82b4f89163131ade3 |
| lexicon:location-derived-identity | anti-pattern | Location-Derived Identity | A defect in which a record's identity is derived from its location or its subject, so renaming either one breaks it. | https://banes-lab.com/json/records/lexicon/location-derived-identity | https://banes-lab.com/records/lexicon/location-derived-identity.md | 3160 | 97bb13d41c419ecfa4b93e1cf33ed9e2837f888f33a942cace4c56e9b210977e |
| lexicon:whole-surface-rewrite | anti-pattern | Whole-Surface Rewrite | A defect in which a shared surface is rewritten whole while a peer is still active on it. | https://banes-lab.com/json/records/lexicon/whole-surface-rewrite | https://banes-lab.com/records/lexicon/whole-surface-rewrite.md | 3127 | 975bf365061942d1eb734bb76b92652309efc8e31c61792a65db5f56ed871e11 |
| lexicon:assumed-single-writer | anti-pattern | Assumed Single Writer | A defect in which the one-writer invariant is assumed to cover a jointly authored surface. | https://banes-lab.com/json/records/lexicon/assumed-single-writer | https://banes-lab.com/records/lexicon/assumed-single-writer.md | 3178 | 5752ecd5cdc0c8061801f409ef7a7c6ebb096ea0dec3e04c001825e330903237 |
| lexicon:fenced-joint-surface | anti-pattern | Fenced Joint Surface | A defect in which a jointly authored surface is fenced into per-party spans. | https://banes-lab.com/json/records/lexicon/fenced-joint-surface | https://banes-lab.com/records/lexicon/fenced-joint-surface.md | 3155 | 1216922995341b34fdc6c13a16acaa6742b77eeb17404ea202016cd0b1576644 |
| lexicon:deferred-projection | anti-pattern | Deferred Projection | A defect in which a surface is updated and its projection is left for a later change. | https://banes-lab.com/json/records/lexicon/deferred-projection | https://banes-lab.com/records/lexicon/deferred-projection.md | 3110 | 8ae0f08ee73c9f6d6ed119a6ea64b251cf2f363bcb802ad3dead10e3112a0526 |
| lexicon:overgrown-projection | anti-pattern | Overgrown Projection | A defect in which a projection grows past the shape its name claims. | https://banes-lab.com/json/records/lexicon/overgrown-projection | https://banes-lab.com/records/lexicon/overgrown-projection.md | 3087 | 1eaedc8cafad97f4abae8fb2e645941b35d65c534572598dcc1c67a7a67d84e7 |
| lexicon:one-way-index-check | anti-pattern | One-Way Index Check | A defect in which an index is checked in one direction only, so an entry with no file or a file with no entry goes unnoticed. | https://banes-lab.com/json/records/lexicon/one-way-index-check | https://banes-lab.com/records/lexicon/one-way-index-check.md | 3155 | 358708b75cb2164f3e5b22149db2918583a5d99e438bd3f091b95c615be5a298 |
| lexicon:single-word-lifetime | anti-pattern | Single-Word Lifetime | A defect in which a lifetime is declared as one word, so a reader infers its other two axes. | https://banes-lab.com/json/records/lexicon/single-word-lifetime | https://banes-lab.com/records/lexicon/single-word-lifetime.md | 3141 | e90fa638255ec0203f502d0590fb007341cb23decfa538b2a21a8737d684e551 |
| lexicon:file-wide-lifetime | anti-pattern | File-Wide Lifetime | A defect in which one lifetime is stated for a file whose sections live differently, so the file's word authorizes operations on a part that forbids them. | https://banes-lab.com/json/records/lexicon/file-wide-lifetime | https://banes-lab.com/records/lexicon/file-wide-lifetime.md | 3195 | 4235aa59ee0c7a9d64167744487ec7f30740e594fd0c1bccd265ad9424dd535a |
| lexicon:conflated-scope | anti-pattern | Conflated Scope | A defect in which one declared scope is used both to detect collisions and to decide whether a result answers a later question. | https://banes-lab.com/json/records/lexicon/conflated-scope | https://banes-lab.com/records/lexicon/conflated-scope.md | 3201 | 78c2d213182afefe7bcefc1bc8bdc35ac4f237df313f921efbc6ac18de4c92e1 |
| lexicon:attached-second-caller | anti-pattern | Attached Second Caller | A defect in which a second caller attaches to a running process instead of reading the result that process publishes. | https://banes-lab.com/json/records/lexicon/attached-second-caller | https://banes-lab.com/records/lexicon/attached-second-caller.md | 3114 | 5cbf93d97d1da842afe7600c8a88ddab5ecb688c584658412407e518084e4134 |
| lexicon:duplicate-covered-run | anti-pattern | Duplicate Covered Run | A defect in which a run is started for a question a live run's scope already covers. | https://banes-lab.com/json/records/lexicon/duplicate-covered-run | https://banes-lab.com/records/lexicon/duplicate-covered-run.md | 3107 | 193b10285f6675994b4380e94dae58f4b2b76075ba649661ce752f08257405f0 |
| lexicon:presence-as-liveness | anti-pattern | Presence as Liveness | A defect in which a process that is present is treated as alive. | https://banes-lab.com/json/records/lexicon/presence-as-liveness | https://banes-lab.com/records/lexicon/presence-as-liveness.md | 3103 | ae7ae456aa8b34af74d3a9e4da95b7a0f6ddc13eb6c650216ddde76ea468c32e |
| lexicon:per-consumer-liveness | anti-pattern | Per-Consumer Liveness | A defect in which each consumer computes liveness separately, so two consumers of one question reach different answers. | https://banes-lab.com/json/records/lexicon/per-consumer-liveness | https://banes-lab.com/records/lexicon/per-consumer-liveness.md | 3152 | c423e69af5afc2a7124b1babb0ef5302c1514e10e583f454611078f8a3b8e79d |
| lexicon:digest-named-channel | anti-pattern | Digest-Named Channel | A defect in which a channel is named by a digest of its scope, which separates channels but cannot be decoded. | https://banes-lab.com/json/records/lexicon/digest-named-channel | https://banes-lab.com/records/lexicon/digest-named-channel.md | 3184 | 195e1e4dece5f69f5f79a779cc35af28b9290b56cb2c4540f9b19fa5b5c76ea4 |
| lexicon:read-before-declare | anti-pattern | Read Before Declare | A defect in which a run reads the set of live runs before writing its own entry, so two starters each see an empty set. | https://banes-lab.com/json/records/lexicon/read-before-declare | https://banes-lab.com/records/lexicon/read-before-declare.md | 3159 | 0e8913a8f133d1ad65cde383fec01cc59fb66b4bd6554880da8db7fbdfc2e3cc |
| lexicon:blanket-collapse | anti-pattern | Blanket Collapse | A defect in which every copy is collapsed toward its source without asking whether any edge ever runs again. | https://banes-lab.com/json/records/lexicon/blanket-collapse | https://banes-lab.com/records/lexicon/blanket-collapse.md | 3161 | 03de2eca11dfcaebb64fae08529f1c26382607f0bacd96e52056f75ee478416d |
| lexicon:preferred-party-count | anti-pattern | Preferred Party Count | A defect in which a party count is chosen as a preference and work is allocated to fit it. | https://banes-lab.com/json/records/lexicon/preferred-party-count | https://banes-lab.com/records/lexicon/preferred-party-count.md | 3083 | 59995c44ed57028c0a71e08710604bfd696cdae7d26bd0f6e9640e718a9f796a |
| lexicon:crowded-surface | anti-pattern | Crowded Surface | A defect in which parties are added who all reason about the same surface. | https://banes-lab.com/json/records/lexicon/crowded-surface | https://banes-lab.com/records/lexicon/crowded-surface.md | 3093 | c96a8db7952d593bff1dc645a61463e688bd9f2b0f48cf36eded14180ffa977b |
| lexicon:single-state-change-check | anti-pattern | Single-State Change Check | A defect in which a rule about how content changes is enforced by a check that reads one state. | https://banes-lab.com/json/records/lexicon/single-state-change-check | https://banes-lab.com/records/lexicon/single-state-change-check.md | 3109 | 7dac63ab02bfd2fe42efd919c9d4f682ea3767553b5fd76f47be9a7151290224 |
| lexicon:remembering-checker | anti-pattern | Remembering Checker | A defect in which a checker keeps its own prior output to judge a change. | https://banes-lab.com/json/records/lexicon/remembering-checker | https://banes-lab.com/records/lexicon/remembering-checker.md | 3133 | e085540bf3ab82c1127dfd7944c7b3d0bd366cbe0e389c326a5f48e6e51957c9 |
| lexicon:prose-parsing-mechanism | anti-pattern | Prose-Parsing Mechanism | A defect in which a mechanism interprets prose to compute a fact. | https://banes-lab.com/json/records/lexicon/prose-parsing-mechanism | https://banes-lab.com/records/lexicon/prose-parsing-mechanism.md | 3121 | cae23bb6e40d6a2e2b71699487a4790102ffdfcaeb04bde88b223e4e03fa473b |
| lexicon:restating-payload | anti-pattern | Restating Payload | A defect in which a payload restates a question its carrier already answers. | https://banes-lab.com/json/records/lexicon/restating-payload | https://banes-lab.com/records/lexicon/restating-payload.md | 3143 | bb28dd606517b1b9a45183ba6f3467e7991ebf4ef86d9d01d834a276e95551b3 |
| lexicon:unread-prose-mandate | anti-pattern | Unread Prose Mandate | A defect in which a field is mandated as free prose while a consumer is assumed to read it. | https://banes-lab.com/json/records/lexicon/unread-prose-mandate | https://banes-lab.com/records/lexicon/unread-prose-mandate.md | 3085 | 27c8930a32e8efca25da9c481f5422f68635f626660b83fb2f203aeba0fa1ceb |
| lexicon:concern-tag | artifact | Concern Tag | A formal definition of the role a file plays, drawn from the closed concern vocabulary and carried as the last dot-segment before the extension. | https://banes-lab.com/json/records/lexicon/concern-tag | https://banes-lab.com/records/lexicon/concern-tag.md | 3669 | 30a338cc50e4d95179cf01b25ef4428cf8d4173162b0e6dce55a4eb135ba2d1f |
| lexicon:subject-slot | mechanism | Subject Slot | A facility that names who or what a file serves, occupying the first dot-segment of the filename. | https://banes-lab.com/json/records/lexicon/subject-slot | https://banes-lab.com/records/lexicon/subject-slot.md | 3567 | c6bfd320553cc35c0a39dfbcfa558854e780d49b66bf80532ce258a33ea851fe |
| lexicon:variant-slot | mechanism | Variant Slot | A facility that narrows a subject to one facet, occupying the segment between subject and concern and present only on collision or facet ambiguity. | https://banes-lab.com/json/records/lexicon/variant-slot | https://banes-lab.com/records/lexicon/variant-slot.md | 4466 | cda13079bfcf36056767c04b262c8f726010971f1572906e73c50074dca7c817 |
| lexicon:container-level | mechanism | Container Level | A facility that partitions a governed root by grouping axis, declared as a closed set and anchoring the depth count at level one. | https://banes-lab.com/json/records/lexicon/container-level | https://banes-lab.com/records/lexicon/container-level.md | 3186 | 227e07c050542f45e76fc6ab8fb99e2e8b10e53ee39b81946644d86cf85c601d |
| lexicon:concern-folder | mechanism | Concern Folder | A facility that holds every file of one concern and whose label the file's concern tag must equal. | https://banes-lab.com/json/records/lexicon/concern-folder | https://banes-lab.com/records/lexicon/concern-folder.md | 3971 | 292161d5cd7261e102a16843ec531874967b7b58d873f63fb7f258c34d4cd3de |
| lexicon:subject-folder | mechanism | Subject Folder | A facility that separates two sets of one concern under a container, present if and only if the sets must not merge. | https://banes-lab.com/json/records/lexicon/subject-folder | https://banes-lab.com/records/lexicon/subject-folder.md | 4066 | 33d0f6850393ea533cffc165c433581b8754ce87585b4b2d25b0946fc10dd810 |
| lexicon:governed-root | constraint | Governed Root | A rule or precondition that a path falls under the taxonomy only where its root is declared, so an undeclared tree is ungoverned and a declared one is governed in full. | https://banes-lab.com/json/records/lexicon/governed-root | https://banes-lab.com/records/lexicon/governed-root.md | 3978 | 798aecf26d2850f8ab6ca3b5814665f22d8cfb4c88cb72c1119dec8e68da5508 |
| lexicon:flat-bucket | mechanism | Flat Bucket | A facility that holds one collection concern as files with no folders beneath it, declared rather than inferred from shape. | https://banes-lab.com/json/records/lexicon/flat-bucket | https://banes-lab.com/records/lexicon/flat-bucket.md | 3696 | 0a297f106dcfb4abbe6939e83d9c40be5cde4a54efa6cbede4ca0e69ef31e114 |
| lexicon:ignore-declaration | artifact | Ignore Declaration | Descriptive data about the names skipped wherever they appear under a governed root, covering build output, vendored sources, tool caches and ecosystem-fixed names. | https://banes-lab.com/json/records/lexicon/ignore-declaration | https://banes-lab.com/records/lexicon/ignore-declaration.md | 3709 | 7d89890f9f584a64982480d30cdb35f2746a58c75d8476685b322959d592d472 |
| lexicon:depth-cap | constraint | Depth Cap | A rule or precondition that every governed file resolve within a fixed number of folders from its governed root, the container included and the file excluded. | https://banes-lab.com/json/records/lexicon/depth-cap | https://banes-lab.com/records/lexicon/depth-cap.md | 3257 | 487014b7dd92038def6e02f306dc0de91f91fdb21ffeb9eddf275c733b293d11 |
| lexicon:ordered-role-sequence | constraint | Ordered Role Sequence | A rule or precondition that each folder depth consume a role strictly later than the depth before it, so container, subject and concern may be skipped but never repeated and never revisited. | https://banes-lab.com/json/records/lexicon/ordered-role-sequence | https://banes-lab.com/records/lexicon/ordered-role-sequence.md | 4164 | 5a462211c44aecd66dc7a12c658e9dfcd405e939a50d5e4dc73259e133882849 |
| lexicon:layer-spine | model | Layer Spine | A conceptual representation of the system-decomposition spectrum that totally orders every concern from domain through product and supplies the tie-break direction. | https://banes-lab.com/json/records/lexicon/layer-spine | https://banes-lab.com/records/lexicon/layer-spine.md | 3271 | e6f08ab4fccb457ae4ad2ac4f309df61c651e2ff239276730235d7e5544a2288 |
| lexicon:collection-concern | artifact | Collection Concern | A formal definition of a concern whose file defines many members at once, plural in both the folder label and the file tag. | https://banes-lab.com/json/records/lexicon/collection-concern | https://banes-lab.com/records/lexicon/collection-concern.md | 3758 | 17caebac22f68776d953e24d4be8679b97ce41f895365083101aff5cd4af61d6 |
| lexicon:single-unit-concern | artifact | Single-Unit Concern | A formal definition of a concern with one instance per file, pairing a plural folder label with a singular file tag. | https://banes-lab.com/json/records/lexicon/single-unit-concern | https://banes-lab.com/records/lexicon/single-unit-concern.md | 3785 | 82f9407728b1205ecc22e019ce3edbddc0ad41584540266497d78172ffabfeac |
| lexicon:glob-resolvability | quality-attribute | Glob Resolvability | The degree to which one depth-unanchored pattern resolves every file or every folder of a concern across the whole tree. | https://banes-lab.com/json/records/lexicon/glob-resolvability | https://banes-lab.com/records/lexicon/glob-resolvability.md | 6136 | 7ba11bf4ed908d062cb994691001bcb9ea26b74a9811bfb3558d9b66171cfd71 |
| lexicon:placement-predictability | quality-attribute | Placement Predictability | The degree to which a file's correct location is derivable from its role alone, with exactly one legal answer. | https://banes-lab.com/json/records/lexicon/placement-predictability | https://banes-lab.com/records/lexicon/placement-predictability.md | 6877 | 62d6e865c12898ca4482716bd1329868068ecad3cbf6cb61d0f359ba5eb470eb |
| lexicon:naming-expressiveness | quality-attribute | Naming Expressiveness | The degree to which a closed vocabulary limits how precisely the developer can name a file that its declared words do not yet cover. | https://banes-lab.com/json/records/lexicon/naming-expressiveness | https://banes-lab.com/records/lexicon/naming-expressiveness.md | 4098 | 0bdb6b9034031456fdc9a6655745a580723501cfe50f0bf734cbcdc0870b3876 |
| lexicon:tree-compactness | quality-attribute | Tree Compactness | The degree to which a small module can stay in few files and folders rather than expanding into one concern folder per role. | https://banes-lab.com/json/records/lexicon/tree-compactness | https://banes-lab.com/records/lexicon/tree-compactness.md | 4105 | fa349f682f7498f81a5b7a18f7b674d86f95495072f05c838878be984aa51166 |
| lexicon:classification-judgment | activity | Classification Judgment | The activity of reading a file and assigning its concern by its primary responsibility, which no pattern-match can perform on its behalf. | https://banes-lab.com/json/records/lexicon/classification-judgment | https://banes-lab.com/records/lexicon/classification-judgment.md | 4040 | b596521cfc192cf147f19ec385616fe58dab7d81c13ccbcae5695ff258e7ce56 |
| lexicon:vocabulary-admission | activity | Vocabulary Admission | The act of reasoning a proposed word against the declared categories and admitting it only by developer-approved registry edit. | https://banes-lab.com/json/records/lexicon/vocabulary-admission | https://banes-lab.com/records/lexicon/vocabulary-admission.md | 4175 | 90cd0ff449ecd011181ea9d60d9fcdd7b5a81824deed37a7ebd99ffb5c00cfca |
| lexicon:identity-migration | activity | Identity Migration | The activity of renaming an artifact and updating every reference to it in the same pass, so no reference is left dangling. | https://banes-lab.com/json/records/lexicon/identity-migration | https://banes-lab.com/records/lexicon/identity-migration.md | 3770 | 992cea87982fed09ffeb27bbd14e8c42e05952aa8c6a1e79e1c709698070dc01 |
| lexicon:shape-discovered-surface | mechanism | Shape-Discovered Surface | A facility that collects its members by matching a pattern rather than by literal path, so a rename silently changes what it collects. | https://banes-lab.com/json/records/lexicon/shape-discovered-surface | https://banes-lab.com/records/lexicon/shape-discovered-surface.md | 3811 | 0420026939a73b0743c9c415786a2b3f9d026bd9b88a5b63edb08d599addc6d8 |
| lexicon:container-by-container-reshape | activity | Container-by-Container Reshape | The practice of converting one container at a time to the taxonomy, updating every reference in the same pass and holding the gate green between each. | https://banes-lab.com/json/records/lexicon/container-by-container-reshape | https://banes-lab.com/records/lexicon/container-by-container-reshape.md | 3323 | 5e800abe70e7d8a1d4a72743cf2a3cd4d96c354d169e704fdbdaeb0b35385c9d |
| lexicon:is-a-test | technique | Is-A Test | A technique for deciding concern membership by asking whether a file is-a the proposed word, admitting it as a role when it is and as a domain noun when the system merely has-a it. | https://banes-lab.com/json/records/lexicon/is-a-test | https://banes-lab.com/records/lexicon/is-a-test.md | 3328 | 66525fce51401b89358191ce889385b131739572578965841ac1fe154908890c |
| lexicon:rejection-table | artifact | Rejection Table | A formal definition of each near-miss word already considered and refused, recording the meta concern that covers it so the same word is not proposed twice. | https://banes-lab.com/json/records/lexicon/rejection-table | https://banes-lab.com/records/lexicon/rejection-table.md | 4007 | 44e3488db9072febc15ff4aa01eb09ebbd5422b97bf35f965a56d1086c8148de |
| lexicon:covering-concern | artifact | Covering Concern | A formal definition of the declared word that already fills a proposed word's role, resolved from the rejection table so a refusal carries its own replacement. | https://banes-lab.com/json/records/lexicon/covering-concern | https://banes-lab.com/records/lexicon/covering-concern.md | 3826 | 3db87e6da987bf7663df832e9d557f274035f110b14788933150423be39376de |
| lexicon:reverse-coverage-resolution | technique | Reverse Coverage Resolution | A technique for answering which declared words cover a candidate, by indexing the rejection table on its refused words rather than on the concerns they map to. | https://banes-lab.com/json/records/lexicon/reverse-coverage-resolution | https://banes-lab.com/records/lexicon/reverse-coverage-resolution.md | 3344 | 12db34fcadb4409f4f44872e5da8dd74ffa5bb0e9a02f2c29a3af748960492f1 |
| lexicon:free-form-folder-level | anti-pattern | Free-Form Folder Level | A folder level resolving to no declared word, so the path is conventional rather than checkable and classification has more than one right answer. | https://banes-lab.com/json/records/lexicon/free-form-folder-level | https://banes-lab.com/records/lexicon/free-form-folder-level.md | 4645 | 2bc4473e91e76298370f4e7f98dc609640bb12e19beaf182b2e7d2ea5b8d8caf |
| lexicon:unguided-refusal | anti-pattern | Unguided Refusal | Reporting an undeclared word without naming the declared word that covers it, so the developer's or the model's next attempt is another guess and the closed set reads as an obstacle rather than a map. | https://banes-lab.com/json/records/lexicon/unguided-refusal | https://banes-lab.com/records/lexicon/unguided-refusal.md | 3825 | f579bc77cbbd6751e0d7cbc554dd2d0edcfab9ca33eda5260f9f719664915614 |
| lexicon:borrowed-synonymy | anti-pattern | Borrowed Synonymy | Deciding whether two declared words overlap from a general-language corpus rather than from the roles they name, so distinct concerns collide on their everyday senses and domain overlaps go unseen. | https://banes-lab.com/json/records/lexicon/borrowed-synonymy | https://banes-lab.com/records/lexicon/borrowed-synonymy.md | 3841 | 96a4a7ef2164fb2b49e334cc0b86a5da0491d467511c9cd0484ee7ef8cf1a2dc |
| lexicon:vocabulary-inflation | anti-pattern | Vocabulary Inflation | Admitting a word whose role a declared word already covers, such as a synonym or an abbreviation of it, so one role gets two words and classification gets two right answers. | https://banes-lab.com/json/records/lexicon/vocabulary-inflation | https://banes-lab.com/records/lexicon/vocabulary-inflation.md | 4983 | f2a3b94dff7370f10eb9700242674f3a62af25f9ac43a8c1a44891ae3dc4e7ce |
| lexicon:ignore-list-silencing | anti-pattern | Ignore-List Silencing | Answering a finding by adding the path to the ignore declaration, removing authored source from the taxonomy entirely and hiding every future violation under the same name. | https://banes-lab.com/json/records/lexicon/ignore-list-silencing | https://banes-lab.com/records/lexicon/ignore-list-silencing.md | 4304 | 8a818e6b65279e82b9ac4e57266fe542caec609aee3dd5ceb7a9872e0433d0f4 |
| lexicon:depth-relief-container | anti-pattern | Depth-Relief Container | Declaring a container to shorten a path or to house files that resist placement, turning the level that anchors the depth count into an escape from it. | https://banes-lab.com/json/records/lexicon/depth-relief-container | https://banes-lab.com/records/lexicon/depth-relief-container.md | 4327 | de95491e85775121e1ec60742c62a92a9053c9b99960e1a5cc9370c9ec276d6a |
| lexicon:restated-set-member | anti-pattern | Restated Set Member | Naming a file with the subject its folder already declares, so the member repeats the set and the name carries no information. | https://banes-lab.com/json/records/lexicon/restated-set-member | https://banes-lab.com/records/lexicon/restated-set-member.md | 3758 | bc17d8a5fa1b7f6e657ee3fd3a9916f46166a0e4e313e0e75972d5c57755c4fb |
| lexicon:saturated-role-tag | anti-pattern | Saturated Role Tag | Classifying a file under a label that names a stature or fits every role, such as util or helper, so it attaches to lifecycle owners, caches, registries and coordinators alike and excludes nothing. | https://banes-lab.com/json/records/lexicon/saturated-role-tag | https://banes-lab.com/records/lexicon/saturated-role-tag.md | 5138 | 348b60977ce021dd4ffc4acc0a62114010baf41c2c3fbe5d0eacaaca475a4517 |
| lexicon:concern-swallowing-compound | anti-pattern | Concern-Swallowing Compound | Fusing a subject and a concern into one word, so the tag that should terminate the name is buried inside it and no glob resolves the file. | https://banes-lab.com/json/records/lexicon/concern-swallowing-compound | https://banes-lab.com/records/lexicon/concern-swallowing-compound.md | 4083 | 4b13b3fb7c27119fce4b28f7080a76af4e55aa71068bd115fb29d50cbbf1d5a6 |
| lexicon:downward-nesting | anti-pattern | Downward Nesting | Relieving collision or breadth pressure by adding a folder level, breaking the depth cap that both overflow slots exist to protect. | https://banes-lab.com/json/records/lexicon/downward-nesting | https://banes-lab.com/records/lexicon/downward-nesting.md | 4481 | 63cd28af4190ee14dcca0f8e506ed019317c3cbf92b8cd2549e4da9c8812836e |
| lexicon:automated-reshape | anti-pattern | Automated Reshape | Renaming by tool across a tree holding shape-discovered surfaces, so the rewrite reports clean while an aggregator that collected by suffix now collects nothing. | https://banes-lab.com/json/records/lexicon/automated-reshape | https://banes-lab.com/records/lexicon/automated-reshape.md | 4195 | 80c370daf69ed82ec05029e455a6eed36fcec90d810623ebdb079cd8b62f1b6d |
| lexicon:nominalized-process-word | anti-pattern | Nominalized Process Word | Admitting a word naming what the system does rather than what it has, so the vocabulary accumulates activities that classify nothing. | https://banes-lab.com/json/records/lexicon/nominalized-process-word | https://banes-lab.com/records/lexicon/nominalized-process-word.md | 4155 | 29f562bea6bd4b19201dc7584d002b92e0952d9bb9a40c8ab4af354e197ff7de |
| lexicon:multi-role-file | anti-pattern | Multi-Role File | Keeping a file whose primary responsibility is two concerns, forcing an arbitrary tag instead of surfacing the split the ambiguity reports. | https://banes-lab.com/json/records/lexicon/multi-role-file | https://banes-lab.com/records/lexicon/multi-role-file.md | 4155 | f651e946882bfff9fde4e42296fc0889c5de531e5a76a1cb402d315420a21c46 |
| lexicon:reasoning-in-the-registry | anti-pattern | Reasoning in the Registry | Writing the rules about a declaration into the declaration file itself, producing a document in a schema's format that no code reads. | https://banes-lab.com/json/records/lexicon/reasoning-in-the-registry | https://banes-lab.com/records/lexicon/reasoning-in-the-registry.md | 3714 | 2cb21827673374462f888d6dac252195ed2ce1a577309e0c62b62bf18d50a6f8 |
| lexicon:mass-concern | artifact | Mass Concern | A formal definition of a concern named for an uncountable role, singular in both the folder label and the file tag, as a configuration or a state is. | https://banes-lab.com/json/records/lexicon/mass-concern | https://banes-lab.com/records/lexicon/mass-concern.md | 4373 | da3c58f23c9dbb64d68c3447b4e9be1b3f89641197ff80213817fbb341c9dcf7 |
| lexicon:compound-marker | artifact | Compound Marker | A formal definition of the declared words, such as test, generated or rule, that exempt a filename from the naming grammar when they sit just before the extension, while the file's placement stays governed. | https://banes-lab.com/json/records/lexicon/compound-marker | https://banes-lab.com/records/lexicon/compound-marker.md | 4687 | 59af87122f5d4f5322e8654dbb3777c2e9982b5433e10588f145f600c519a604 |
| lexicon:ecosystem-fixed-name | artifact | Ecosystem-Fixed Name | Descriptive data about the filenames an external tool finds by exact name, such as package manifests, lockfiles and compiler configurations, which are never renamed to the grammar. | https://banes-lab.com/json/records/lexicon/ecosystem-fixed-name | https://banes-lab.com/records/lexicon/ecosystem-fixed-name.md | 3828 | 368a5f4aefd6a6b21687526953c1e9d4aaa9500e836a35667862ea0e74a7e38e |
| lexicon:structurally-exempt-file | artifact | Structurally Exempt File | Descriptive data about the files that carry their own resolution contract, such as an aggregator collected by shape, a build entry named in an entry map, and a generated file rewritten on every run. | https://banes-lab.com/json/records/lexicon/structurally-exempt-file | https://banes-lab.com/records/lexicon/structurally-exempt-file.md | 3852 | 2d90d5ab1857e272821305b37a40ef9b98ed149670e102c3a7ca3e71b730e7ec |
| lexicon:conversion-record | artifact | Conversion Record | A formal definition of the record written for each file a conversion names, holding its responsibilities with the symbols behind them, its chosen concern and subject, the candidates refused, and the verdict on any file that shares its job. | https://banes-lab.com/json/records/lexicon/conversion-record | https://banes-lab.com/records/lexicon/conversion-record.md | 3388 | 6d890bed7bdadc8c0eea301295e5d96c543c7446057e161340b101974e5e43e6 |
| lexicon:alignment-entry | artifact | Alignment Entry | Descriptive data about one whole reading of a conversion protocol, carrying the content hash of the revision read and the scope it covers, which every conversion record written after it cites. | https://banes-lab.com/json/records/lexicon/alignment-entry | https://banes-lab.com/records/lexicon/alignment-entry.md | 3830 | 1ab2277ab09ea326b29ae4842d7dd099e5ade3fd242ab7eed0dfad4361b2ff5b |
| lexicon:re-alignment-cadence | constraint | Re-Alignment Cadence | A rule or precondition that only a bounded run of conversion records may cite one alignment entry, so a long conversion re-reads its protocol before the rules it applies fade from working context. | https://banes-lab.com/json/records/lexicon/re-alignment-cadence | https://banes-lab.com/records/lexicon/re-alignment-cadence.md | 3314 | 8c4fe17d614e356ed1085c782d1d7c734ca99ea32a8f843c9c1a6fa4d7f7a1bf |
| lexicon:frozen-baseline | artifact | Frozen Baseline | Descriptive data about the files already conformant when a conversion's record gate shipped, pinned once into a generated set that never grows, so only a file renamed or moved afterwards owes a record. | https://banes-lab.com/json/records/lexicon/frozen-baseline | https://banes-lab.com/records/lexicon/frozen-baseline.md | 3844 | 3b4be48da47cbc6c402993419c49e15e277338710c9b129b4d6880cca9dfbbbf |
| lexicon:word-boundary-case | artifact | Word-Boundary Case | A formal definition of a naming case by where one word ends and the next begins, whether at a capital letter as in camel and pascal case or at a joiner as in snake and kebab case. | https://banes-lab.com/json/records/lexicon/word-boundary-case | https://banes-lab.com/records/lexicon/word-boundary-case.md | 3790 | 5e1eec54c5b0190f86f146512dc63e10dd8276995b4cd248c0280359b1f3adfa |
| lexicon:unreferenced-export-triage | activity | Unreferenced Export Triage | The activity of deciding, for each export nothing imports, whether a call site should use it, whether it is capability waiting for a consumer, whether it is superseded, or whether it went with a merged duplicate. | https://banes-lab.com/json/records/lexicon/unreferenced-export-triage | https://banes-lab.com/records/lexicon/unreferenced-export-triage.md | 3919 | 106d52b88034099b053879f7b4a26a582e5d6abd388041f7e7d56efdf5e0bec5 |
| lexicon:variant-masked-duplicate | anti-pattern | Variant-Masked Duplicate | Resolving a naming collision by giving the second file a variant, so two files doing one job keep two names and the duplication becomes permanent. | https://banes-lab.com/json/records/lexicon/variant-masked-duplicate | https://banes-lab.com/records/lexicon/variant-masked-duplicate.md | 3783 | 2ed2ac05669ce07da976592b35fe768b8d4460129de36471e6d82f9f59c3f0e8 |
| lexicon:stranded-test | anti-pattern | Stranded Test | Leaving a test where its subject used to sit after the subject moves or splits, so the test tree no longer shows which tests cover which file. | https://banes-lab.com/json/records/lexicon/stranded-test | https://banes-lab.com/records/lexicon/stranded-test.md | 3755 | b15776485eb0608ee90fe26a7d1542a0e68e4daac6023aaa1385627a79b9dc58 |
| lexicon:adjective-slot-word | anti-pattern | Adjective Slot Word | Admitting an adjective such as lazy, bounded or shallow into a name slot, where no category can take it, so it describes a file without classifying it. | https://banes-lab.com/json/records/lexicon/adjective-slot-word | https://banes-lab.com/records/lexicon/adjective-slot-word.md | 3718 | f2fe24e31ffd873ab9fe6533ba2366b9632fc253c68639596de04b58b49c7a59 |
| lexicon:plural-subject | anti-pattern | Plural Subject | Using a plural noun such as stats or fields as a subject, where a subject names one thing the system has. | https://banes-lab.com/json/records/lexicon/plural-subject | https://banes-lab.com/records/lexicon/plural-subject.md | 3682 | d0652450b0c2ddac12092e936ca03b71f8a2314e0b45455c6265b23d9d130728 |
| lexicon:grouping-label | anti-pattern | Grouping Label | Using a bucket word such as misc, common, shared or core as a subject, which excludes no file and so classifies none, although grouping is exactly what a container is for. | https://banes-lab.com/json/records/lexicon/grouping-label | https://banes-lab.com/records/lexicon/grouping-label.md | 3271 | 861830df74a9b3f5588bb42a6ffce6d91082a147488a3c71e4badbed164830bd |
| lexicon:measurement-word | anti-pattern | Measurement Word | Admitting a measurement or property such as duration, interval or budget as a vocabulary word, where it names data held in a file rather than a role or a thing. | https://banes-lab.com/json/records/lexicon/measurement-word | https://banes-lab.com/records/lexicon/measurement-word.md | 3770 | b080a63c921ae7564ec3e9480768effeead1d7d763dba1e0ff697b08d17f3021 |
| lexicon:instance-identifier-word | anti-pattern | Instance Identifier Word | Admitting the id of one registry entry, such as primary or dark-mode, into a vocabulary, so content enters a list that should hold only kinds of thing. | https://banes-lab.com/json/records/lexicon/instance-identifier-word | https://banes-lab.com/records/lexicon/instance-identifier-word.md | 3783 | 6703c509771f6d7ea39a2ca98178da630814cb513b01d0ae598e02a69447c4d4 |
| lexicon:sentence-shaped-name | anti-pattern | Sentence-Shaped Name | Naming a file after an activity or a sentence because its role would not resolve, when the name's resistance shows that the file needs a split, a move or a merge. | https://banes-lab.com/json/records/lexicon/sentence-shaped-name | https://banes-lab.com/records/lexicon/sentence-shaped-name.md | 3833 | 4fd50218d4c9b8d313048513a90eadf850707820d00d612a12758209ff63b9be |
| lexicon:numeric-order-prefix | anti-pattern | Numeric Order Prefix | Encoding a file's place in a sequence as a numeric prefix, so inserting one step renames every file after it and the grammar must parse a number it cannot classify. | https://banes-lab.com/json/records/lexicon/numeric-order-prefix | https://banes-lab.com/records/lexicon/numeric-order-prefix.md | 3750 | 4dd8e02fb4b9d507d1f7f4fb230c813d2076dce13480d4ce4bd0e98b17b711cd |
| lexicon:claimed-foreign-tree | anti-pattern | Claimed Foreign Tree | Declaring a tree that another runtime resolves by name a governed root and renaming it to the grammar, which breaks that runtime at its next start without reorganizing anything. | https://banes-lab.com/json/records/lexicon/claimed-foreign-tree | https://banes-lab.com/records/lexicon/claimed-foreign-tree.md | 4370 | 384bdc708f35d622dd412613b87231dce650c10598226e168376619118f4db78 |
| lexicon:rename-to-a-declared-word | technique | Rename to a Declared Word | A technique for replacing an undeclared word in a name with the declared word that covers its role. | https://banes-lab.com/json/records/lexicon/rename-to-a-declared-word | https://banes-lab.com/records/lexicon/rename-to-a-declared-word.md | 3234 | 9fa2d15f8ca06901a5c2e7e26a7d3c27f80c32eff4f01dad9751690ffab9def1 |
| lexicon:split-the-compound | technique | Split the Compound | A technique for separating a word that fused a subject and a concern into its two slots. | https://banes-lab.com/json/records/lexicon/split-the-compound | https://banes-lab.com/records/lexicon/split-the-compound.md | 3335 | 1fd26af1f2f9ca4df81d8126616715cd922676c96b36a6d09aea32cc9682e4f5 |
| lexicon:move-the-tag-to-the-concern-slot | technique | Move the Tag to the Concern Slot | A technique for placing a concern tag as the last segment of a filename, where the parser reads the concern. | https://banes-lab.com/json/records/lexicon/move-the-tag-to-the-concern-slot | https://banes-lab.com/records/lexicon/move-the-tag-to-the-concern-slot.md | 3316 | 0092582db088c6b70c09f4f8ae938eb7b833f0b6545c06716f12cdce5caec631 |
| lexicon:correct-the-resolver | technique | Correct the Resolver | A technique for fixing a slot resolver that reads a word by its vocabulary instead of by its position. | https://banes-lab.com/json/records/lexicon/correct-the-resolver | https://banes-lab.com/records/lexicon/correct-the-resolver.md | 3407 | 01124768bd6d676aabc7ab0c538779d039ab891b42e201fbb0258652aaf7508e |
| lexicon:move-to-the-matching-concern-folder | technique | Move to the Matching Concern Folder | A technique for moving a file into the folder whose label equals its concern tag. | https://banes-lab.com/json/records/lexicon/move-to-the-matching-concern-folder | https://banes-lab.com/records/lexicon/move-to-the-matching-concern-folder.md | 3321 | 3720999b80bb30295346cc3eb9d38a1a767ef26bcdc586f340ce71137c517cf2 |
| lexicon:reclassify-the-file | technique | Reclassify the File | A technique for reading a file again and giving it the concern tag its code supports. | https://banes-lab.com/json/records/lexicon/reclassify-the-file | https://banes-lab.com/records/lexicon/reclassify-the-file.md | 3341 | cdfb0b9a46e853e22464e8563428c100c5c2a329555f40b88130e0d7c21cb75e |
| lexicon:unanchor-the-pattern | technique | Unanchor the Pattern | A technique for writing a discovery pattern that matches a concern at any depth instead of at one. | https://banes-lab.com/json/records/lexicon/unanchor-the-pattern | https://banes-lab.com/records/lexicon/unanchor-the-pattern.md | 3268 | f02e0102c0c1417dcde039abcdd10405d9b8b2a573c0e2093ed3dc6a47c7c422 |
| lexicon:restore-the-terminating-tag | technique | Restore the Terminating Tag | A technique for ending a filename with its concern tag again, so a glob on the tag finds it. | https://banes-lab.com/json/records/lexicon/restore-the-terminating-tag | https://banes-lab.com/records/lexicon/restore-the-terminating-tag.md | 3240 | 61a93ab237c89e0c9dc2e8b9594a5e6b277cd1cda463a5a21d5023784e624890 |
| lexicon:declare-the-root | technique | Declare the Root | A technique for adding a folder to the jurisdiction declaration instead of inferring that it is governed. | https://banes-lab.com/json/records/lexicon/declare-the-root | https://banes-lab.com/records/lexicon/declare-the-root.md | 3374 | 03144ee4c1c57cfec13d550509886fa78fd3c49543ee660eee641b9ddb32e047 |
| lexicon:place-the-folder-in-an-existing-container | technique | Place the Folder in an Existing Container | A technique for moving a folder under the container that already groups its kind of content. | https://banes-lab.com/json/records/lexicon/place-the-folder-in-an-existing-container | https://banes-lab.com/records/lexicon/place-the-folder-in-an-existing-container.md | 3316 | c7aa189c14ee9c834ba3917e82f8cf86e39422f0c2dc9b2bafb3fe6256c59399 |
| lexicon:remove-the-ignore-entry | technique | Remove the Ignore Entry | A technique for deleting an ignore entry that hid authored source and fixing the finding it silenced. | https://banes-lab.com/json/records/lexicon/remove-the-ignore-entry | https://banes-lab.com/records/lexicon/remove-the-ignore-entry.md | 3403 | 8220baea93cbbdd87a3306a248d89694e42117827728dc5a341ea9a00737c2fb |
| lexicon:collapse-the-exemption-lists | technique | Collapse the Exemption Lists | A technique for replacing per-check exemption lists for one upstream tree with a single declaration every check reads. | https://banes-lab.com/json/records/lexicon/collapse-the-exemption-lists | https://banes-lab.com/records/lexicon/collapse-the-exemption-lists.md | 3315 | 7c11710a29baf10562b4f04ed8781d76b8616551db6ca6da1c468d6f75c7338f |
| lexicon:take-the-variant-slot | technique | Take the Variant Slot | A technique for resolving a name collision with a declared variant instead of a new folder level. | https://banes-lab.com/json/records/lexicon/take-the-variant-slot | https://banes-lab.com/records/lexicon/take-the-variant-slot.md | 3696 | 82d568f27e8bd413f9aeece362aa145b6c56360ff45c92e5d4c342de33d93b77 |
| lexicon:add-a-sibling-subject-folder | technique | Add a Sibling Subject Folder | A technique for relieving breadth with a subject folder beside the existing one instead of below it. | https://banes-lab.com/json/records/lexicon/add-a-sibling-subject-folder | https://banes-lab.com/records/lexicon/add-a-sibling-subject-folder.md | 3667 | 13f6c7f1feb4447de665b4b4bd0f9e422d45f86ff0de41134a21f91f50f6ee2f |
| lexicon:split-by-responsibility | technique | Split by Responsibility | A technique for dividing a file that holds two concerns into one file per concern. | https://banes-lab.com/json/records/lexicon/split-by-responsibility | https://banes-lab.com/records/lexicon/split-by-responsibility.md | 3329 | 05d15c5ebd7224cd1923569c176a53a2448ac31ee335c34b92b9b7f36ae35e33 |
| lexicon:reclassify-to-the-narrower-role | technique | Reclassify to the Narrower Role | A technique for moving a file from a broad concern tag to the narrowest tag that still fits it. | https://banes-lab.com/json/records/lexicon/reclassify-to-the-narrower-role | https://banes-lab.com/records/lexicon/reclassify-to-the-narrower-role.md | 3334 | a6acf8f64bfa34ce4126d7b2ee475527e44ea2b10451f2025419e6e22d1df802 |
| lexicon:apply-the-domain-ward-tie-break | technique | Apply the Domain-Ward Tie-Break | A technique for resolving an irreducible two-concern overlap toward the concern nearer the domain on the layer spine. | https://banes-lab.com/json/records/lexicon/apply-the-domain-ward-tie-break | https://banes-lab.com/records/lexicon/apply-the-domain-ward-tie-break.md | 3406 | 6288a0e215314bc8dd82558b1df379629db0905d9d924bedcf2185f03701a713 |
| lexicon:classify-to-the-meta-concern | technique | Classify to the Meta Concern | A technique for tagging a file with the agnostic concern that covers its role instead of a domain word. | https://banes-lab.com/json/records/lexicon/classify-to-the-meta-concern | https://banes-lab.com/records/lexicon/classify-to-the-meta-concern.md | 3460 | e6155d634fba712877fc2a28ced3a7084a0961d0c1a0617f3651e73e65e684c7 |
| lexicon:index-the-rejection-table-by-refused-word | technique | Index the Rejection Table by Refused Word | A technique for keying the table of rejected words by the refused word, so the gate can look up its replacement. | https://banes-lab.com/json/records/lexicon/index-the-rejection-table-by-refused-word | https://banes-lab.com/records/lexicon/index-the-rejection-table-by-refused-word.md | 3501 | 789105a1506e9651730bb074171803b0c5b7ea451a9c21a0c70f103c77ca238e |
| lexicon:name-the-covering-concern-in-the-refusal | technique | Name the Covering Concern in the Refusal | A technique for having a vocabulary refusal name the declared word that covers the refused one. | https://banes-lab.com/json/records/lexicon/name-the-covering-concern-in-the-refusal | https://banes-lab.com/records/lexicon/name-the-covering-concern-in-the-refusal.md | 3530 | 9aa62d5051491b0f586c1f2384d6b6715aba5103c9713efd5c72e4a0fbec126c |
| lexicon:derive-the-registry-from-the-document | technique | Derive the Registry from the Document | A technique for generating the machine-read vocabulary from the document that reasons about it, so the two cannot drift. | https://banes-lab.com/json/records/lexicon/derive-the-registry-from-the-document | https://banes-lab.com/records/lexicon/derive-the-registry-from-the-document.md | 3518 | d9897501f44df55e0566b9db63d75b889c776bcff453a293cb29f10be15ea6b4 |
| lexicon:move-reasoning-back-to-the-document | technique | Move Reasoning Back to the Document | A technique for moving rules written into a declaration file back into the document that people read. | https://banes-lab.com/json/records/lexicon/move-reasoning-back-to-the-document | https://banes-lab.com/records/lexicon/move-reasoning-back-to-the-document.md | 3416 | d015f9f40a4aac8bf20462c6207487136ca46fed6442cedad123b5f930249dc2 |
| lexicon:drop-the-redundant-head | technique | Drop the Redundant Head | A technique for removing from a filename the subject its folder already declares. | https://banes-lab.com/json/records/lexicon/drop-the-redundant-head | https://banes-lab.com/records/lexicon/drop-the-redundant-head.md | 3328 | a910dc33580380d9b75df31a44ea52400a4b641136830229da367f482e7697f4 |
| lexicon:re-point-the-pattern | technique | Re-Point the Pattern | A technique for updating every shape-discovered surface whose pattern encoded a renamed form. | https://banes-lab.com/json/records/lexicon/re-point-the-pattern | https://banes-lab.com/records/lexicon/re-point-the-pattern.md | 3303 | c0dce24914c564fd8fffd787375f67debfd42c1d64b6512cb4517b56219aeefe |
| lexicon:verify-the-collected-count | technique | Verify the Collected Count | A technique for comparing what each aggregator collects before and after a rename, treating a drop to zero as a failure. | https://banes-lab.com/json/records/lexicon/verify-the-collected-count | https://banes-lab.com/records/lexicon/verify-the-collected-count.md | 3299 | 34ddf164260a38bfa93adb2282fa7aa699b9bee3c6154b5e703e10d3af223893 |
| lexicon:compare-both-files | technique | Compare Both Files | A technique for comparing the responsibilities of two colliding files before giving either a variant. | https://banes-lab.com/json/records/lexicon/compare-both-files | https://banes-lab.com/records/lexicon/compare-both-files.md | 3333 | 3fc1f5e5eb0b50888f4637a34ef660f871829b73a5c2f8c2bfacafe689dae745 |
| lexicon:merge-one-job-or-name-the-facet | technique | Merge One Job or Name the Facet | A technique for merging two files that do one job, or giving the variant the facet that truly differs. | https://banes-lab.com/json/records/lexicon/merge-one-job-or-name-the-facet | https://banes-lab.com/records/lexicon/merge-one-job-or-name-the-facet.md | 3341 | 85aef41f7db9a1260052e62a7abcac3def4ed195795d68da75ea5f06b0f2b1e7 |
| lexicon:move-the-test-with-its-subject | technique | Move the Test with Its Subject | A technique for moving a test to the mirrored path of its subject whenever the subject moves. | https://banes-lab.com/json/records/lexicon/move-the-test-with-its-subject | https://banes-lab.com/records/lexicon/move-the-test-with-its-subject.md | 3373 | 2b469f00d947afe093990b807f0953436810c8ed5fdda1bd9bb0af0cbfc79606 |