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

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

| ref | kind | title | summary | json | markdown | bytes | fingerprint |
| --- | --- | --- | --- | --- | --- | --- | --- |
| lexicon:cross-system-communication | capability | Cross-System Communication | The ability for independent systems to exchange and understand data with one another. | https://banes-lab.com/json/records/lexicon/cross-system-communication | https://banes-lab.com/records/lexicon/cross-system-communication.md | 3256 | d033aef3e1bbdff6e86c7b2561b9a12df9f8b3317d1aed458a699247ef1141a6 |
| lexicon:incremental-deployment | capability | Incremental Deployment | The ability to roll out changes gradually while old and new versions coexist. | https://banes-lab.com/json/records/lexicon/incremental-deployment | https://banes-lab.com/records/lexicon/incremental-deployment.md | 3307 | 814e32deeebc167e4d9afcaea0285222416ba6969cf31a71bc18dd0a31065daa |
| lexicon:independent-consumers | capability | Independent Consumers | The ability for consumers to evolve on their own schedule because the interface stays stable. | https://banes-lab.com/json/records/lexicon/independent-consumers | https://banes-lab.com/records/lexicon/independent-consumers.md | 3289 | 07130661eaf4037b807c98afba8fb7d270bb6d4c3139d01b583343ddd3222aab |
| lexicon:multi-client-integration | capability | Multi-Client Integration | The ability to serve many different clients through one compatible protocol. | https://banes-lab.com/json/records/lexicon/multi-client-integration | https://banes-lab.com/records/lexicon/multi-client-integration.md | 3294 | 0b598e185fa3c7ff1b71d9e70d8a9968d0ca1346980f49cd975139c7f7207218 |
| lexicon:provider-change-safety | quality-attribute | Provider Change Safety | The degree to which a provider can change without breaking its consumers, verified by their contracts. | https://banes-lab.com/json/records/lexicon/provider-change-safety | https://banes-lab.com/records/lexicon/provider-change-safety.md | 3339 | 660509301e59d57d3a9cd9b2197f5844340de04d78483558cba9bd8e4ebb322c |
| lexicon:reliable-integration | quality-attribute | Reliable Integration | The degree to which systems integrate correctly because their shared meaning is agreed, not just their shape. | https://banes-lab.com/json/records/lexicon/reliable-integration | https://banes-lab.com/records/lexicon/reliable-integration.md | 3273 | ce875b2adca55d8a2a0dfd081e0f7ae2592a1cfac7b85a4e5f782fed4e705dfd |
| lexicon:rolling-upgrades | capability | Rolling Upgrades | The ability to upgrade instances one at a time while old and new versions interoperate. | https://banes-lab.com/json/records/lexicon/rolling-upgrades | https://banes-lab.com/records/lexicon/rolling-upgrades.md | 3233 | 8defc1a69a5c1f15fda4d304e721fbc6c30512a42f7ea7b3abf7375e1e9d06be |
| lexicon:schema-evolution | capability | Schema Evolution | The ability to change a data schema over time without breaking existing readers or writers. | https://banes-lab.com/json/records/lexicon/schema-evolution | https://banes-lab.com/records/lexicon/schema-evolution.md | 3172 | b268026093f7a9862bb98a853888e295c18d1486e45745261c28f4c436922a47 |
| lexicon:consumer-safety | quality-attribute | Consumer Safety | The degree to which consumers are protected from breakage when a provider changes. | https://banes-lab.com/json/records/lexicon/consumer-safety | https://banes-lab.com/records/lexicon/consumer-safety.md | 3199 | 16962b4eb4248aebff078398098947ea4950a90288d3c74cfb23e94985c21870 |
| lexicon:data-quality | quality-attribute | Data Quality | The degree to which data is accurate, complete, and fit for its intended use. | https://banes-lab.com/json/records/lexicon/data-quality | https://banes-lab.com/records/lexicon/data-quality.md | 3127 | 6414b76928d17576e3ae9d66c954db28570231131b92d6c04676d81a33d07204 |
| lexicon:integration | quality-attribute | Integration | The degree to which separate systems are connected to operate as a unified whole. | https://banes-lab.com/json/records/lexicon/integration | https://banes-lab.com/records/lexicon/integration.md | 3736 | dc366c69c3d626d8c697bdb36e01d5886c87dc959bbf77f9f74aee9eaedc41c1 |
| lexicon:cleanup-simplification | activity | Cleanup / Simplification | The activity of removing obsolete code and structure, which backward compatibility can hold back. | https://banes-lab.com/json/records/lexicon/cleanup-simplification | https://banes-lab.com/records/lexicon/cleanup-simplification.md | 6124 | 6bfbbacf2eaf7e0d6556a8546eacc2e7cf5d829606c7715df97c7dc165d57978 |
| lexicon:cross-domain-translation | activity | Cross-Domain Translation | The activity of mapping terms and structures between two domains that model the world differently. | https://banes-lab.com/json/records/lexicon/cross-domain-translation | https://banes-lab.com/records/lexicon/cross-domain-translation.md | 4124 | ef46ab6fb413667a44b4a8b9fb7ebdd862ab30ddd17d022cc061badbbfdd5655 |
| lexicon:development-speed | metric | Development Speed | The rate at which new functionality is built, which upfront contract rigor can slow. | https://banes-lab.com/json/records/lexicon/development-speed | https://banes-lab.com/records/lexicon/development-speed.md | 4073 | c2284085d69ddcd4e69f85e9db6f0f6ba248a1a543d64d230240f9b1e8394f69 |
| lexicon:distributed-evolution | quality-attribute | Distributed Evolution | The degree to which services can evolve independently, constrained by the contracts binding them. | https://banes-lab.com/json/records/lexicon/distributed-evolution | https://banes-lab.com/records/lexicon/distributed-evolution.md | 4113 | 6cad11c6699e631166e71bed748a45bea43ed13fcb2fec82f59d030580620dd4 |
| lexicon:domain-specific-optimization | quality-attribute | Domain-Specific Optimization | The degree to which a system is tuned for one domain, traded against broad interoperability. | https://banes-lab.com/json/records/lexicon/domain-specific-optimization | https://banes-lab.com/records/lexicon/domain-specific-optimization.md | 4096 | 9eb42bacef06a1b454f44eac5e6b7879026b113b05a547e6c743e1bac8a0bf11 |
| lexicon:evolution | capability | Evolution | The ability to change an interface over time, in tension with the stability its contract promises. | https://banes-lab.com/json/records/lexicon/evolution | https://banes-lab.com/records/lexicon/evolution.md | 3949 | 67c87d9c2bdf1b587813ebc660247d25cff5ccc8baff292a015c6b821ff806f1 |
| lexicon:evolution-speed | metric | Evolution Speed | The rate at which an interface can change, which a commitment to stability deliberately limits. | https://banes-lab.com/json/records/lexicon/evolution-speed | https://banes-lab.com/records/lexicon/evolution-speed.md | 3931 | 4e3aca02d252304e12f0dd3354cc7233b0d4a44b0a168fd475460c1b645ddadf |
| lexicon:flexibility | quality-attribute | Flexibility | The degree to which a component permits varied use, in tension with the invariants it must uphold. | https://banes-lab.com/json/records/lexicon/flexibility | https://banes-lab.com/records/lexicon/flexibility.md | 3894 | 9a1be15df7dfc767f918cfa447fa0e3de5bf343745d12e73eb7802cbd9d30223 |
| lexicon:flexible-ingestion | quality-attribute | Flexible Ingestion | The degree to which a system accepts loosely-structured input, in tension with a strict data contract. | https://banes-lab.com/json/records/lexicon/flexible-ingestion | https://banes-lab.com/records/lexicon/flexible-ingestion.md | 3976 | 82fab328846ee0d7587b52038c65d5bbe1b08251d37aa1141bfa8a51837ba1a1 |
| lexicon:interface-overuse | quality-attribute | Interface Overuse | The degree to which excessive interface abstraction adds indirection without proportional benefit. | https://banes-lab.com/json/records/lexicon/interface-overuse | https://banes-lab.com/records/lexicon/interface-overuse.md | 4078 | a50b341820bedc9ac3730a12867e77f12830330cb66b85022425b53337ad5ec5 |
| lexicon:permissive-apis | quality-attribute | Permissive APIs | The degree to which an API accepts loose or lenient input, in tension with strict preconditions. | https://banes-lab.com/json/records/lexicon/permissive-apis | https://banes-lab.com/records/lexicon/permissive-apis.md | 3993 | e9351fed9941d9e0ecce8c0324e25641e5ce230b7c88d8a3f02383227fc6af9f |
| lexicon:protocol-optimization | quality-attribute | Protocol Optimization | The degree to which a protocol is tuned for performance, traded against broad compatibility. | https://banes-lab.com/json/records/lexicon/protocol-optimization | https://banes-lab.com/records/lexicon/protocol-optimization.md | 4103 | e6fe5e3eca706576fb10c56b9e7b3ea0da4d29ac3f13f73baacef4b672e28491 |
| lexicon:provider-autonomy | quality-attribute | Provider Autonomy | The degree of freedom a provider retains to change, constrained by consumer-driven contracts. | https://banes-lab.com/json/records/lexicon/provider-autonomy | https://banes-lab.com/records/lexicon/provider-autonomy.md | 4128 | 03f5c69196d8e79dd405f2dfcdd3c6fef599a356085b675f507eea2ab5be9d07 |
| lexicon:rapid-prototyping | activity | Rapid Prototyping | The activity of building quick throwaway prototypes, which explicit contracts can slow. | https://banes-lab.com/json/records/lexicon/rapid-prototyping | https://banes-lab.com/records/lexicon/rapid-prototyping.md | 3998 | 92fab4ef970028760e00d3f807f96bc107eaadeeaf1e99bc0c2d3ea7dfe94965 |
| lexicon:runtime-cost | quality-attribute | Runtime Cost | The degree of runtime overhead incurred by checking conditions on every call. | https://banes-lab.com/json/records/lexicon/runtime-cost | https://banes-lab.com/records/lexicon/runtime-cost.md | 3942 | f32a1265826d3b687732daa02534d717baac4f0aeacb70a5fe480d84964dfa56 |
| lexicon:schema-flexibility | quality-attribute | Schema Flexibility | The degree to which a schema tolerates variation, in tension with a strict contract. | https://banes-lab.com/json/records/lexicon/schema-flexibility | https://banes-lab.com/records/lexicon/schema-flexibility.md | 4003 | c5fcd2f9063adc40c0ac9b83020a6d9c4439556d59ae8424b61957dc2032f720 |
| lexicon:specialized-endpoints | quality-attribute | Specialized Endpoints | The degree to which purpose-built endpoints are offered, traded against a uniform interface. | https://banes-lab.com/json/records/lexicon/specialized-endpoints | https://banes-lab.com/records/lexicon/specialized-endpoints.md | 4068 | 1d3515659fed3057b3a9561c241c8f02813cf20f90bba2b5ce954402a9ea9931 |
| lexicon:strong-validation | quality-attribute | Strong Validation | The degree to which input is strictly validated, in tension with tolerating unknown future fields. | https://banes-lab.com/json/records/lexicon/strong-validation | https://banes-lab.com/records/lexicon/strong-validation.md | 4078 | b3eea8f73beb26a461bd370929ee752e355df1ec542c37d9359dd466eb67f2ed |
| lexicon:version-sprawl | quality-attribute | Version Sprawl | The degree to which many concurrent versions accumulate and must be maintained. | https://banes-lab.com/json/records/lexicon/version-sprawl | https://banes-lab.com/records/lexicon/version-sprawl.md | 3947 | 3354b906f1d1668ac34c0811bd38c4eaf6e9d2ec29d3267fd87edaa02268ba32 |
| lexicon:standard-error-contract | technique | Standard Error Contract | A technique for giving every error one published shape with a code, a message and its context. | https://banes-lab.com/json/records/lexicon/standard-error-contract | https://banes-lab.com/records/lexicon/standard-error-contract.md | 5396 | c83ab1b39e6d42044f3fc56eeb0a9dfe7f7e10891a6142e83539dae87ded0616 |
| lexicon:introduce-boundary-dto | technique | Introduce Boundary DTO | A technique for carrying data across a boundary in a transfer object, so internal models stay inside. | https://banes-lab.com/json/records/lexicon/introduce-boundary-dto | https://banes-lab.com/records/lexicon/introduce-boundary-dto.md | 6867 | 003cec88b5ffa0172af2219c661037236f95a9f7371004b85624a2c2269a9bcf |
| lexicon:coarse-grained-endpoint | technique | Coarse-Grained Endpoint | A technique for serving one client operation with one call that returns everything the operation needs. | https://banes-lab.com/json/records/lexicon/coarse-grained-endpoint | https://banes-lab.com/records/lexicon/coarse-grained-endpoint.md | 3596 | acdc375fd2bf5ec84accb6b882f90867694b2de756a4b33768379fdd5f80f781 |
| lexicon:backward-compatible-change | technique | Backward-Compatible Change | A technique for changing a contract only by additions that existing consumers can ignore. | https://banes-lab.com/json/records/lexicon/backward-compatible-change | https://banes-lab.com/records/lexicon/backward-compatible-change.md | 3624 | 199877da1b7121e0415ee16e4db1baa1490b79d41d2a021ddf29563e007ebe46 |
| lexicon:compatibility-adapter | technique | Compatibility Adapter | A technique for serving an old contract through an adapter over the new one while consumers migrate. | https://banes-lab.com/json/records/lexicon/compatibility-adapter | https://banes-lab.com/records/lexicon/compatibility-adapter.md | 3655 | c77ce902ac9c94e5ace060e347679f6da980eb1058d6eb8a3f0289549acaf420 |
| lexicon:gradual-deprecation | technique | Gradual Deprecation | A technique for announcing a removal with a date, warning the consumers still using it, and removing it after the date. | https://banes-lab.com/json/records/lexicon/gradual-deprecation | https://banes-lab.com/records/lexicon/gradual-deprecation.md | 4498 | 0e6df0d8fbaf84d51598c180bba7d142631670d7b99bccead1908057f946cfae |
| lexicon:migration-guide | technique | Migration Guide | A technique for publishing the steps a consumer takes to move from one version of a contract to the next. | https://banes-lab.com/json/records/lexicon/migration-guide | https://banes-lab.com/records/lexicon/migration-guide.md | 3141 | 85c22734187669b60d19f85cee38a42ac697dd30bd20115d5071859d26961d13 |
| lexicon:version-bump | technique | Version Bump | A technique for raising a contract's version number by the rule that says which kind of change it carries. | https://banes-lab.com/json/records/lexicon/version-bump | https://banes-lab.com/records/lexicon/version-bump.md | 3200 | 55e6fe23aa608f7461bd689408dfe6ffcee8f1ffd08449dfbfd19e735847282c |
| lexicon:consumer-driven-contract-tests | technique | Consumer-Driven Contract Tests | A technique for having each consumer publish the responses it relies on and testing the provider against all of them before it releases. | https://banes-lab.com/json/records/lexicon/consumer-driven-contract-tests | https://banes-lab.com/records/lexicon/consumer-driven-contract-tests.md | 5511 | 2c0850bb2af58eee046a182882a0daf5e13a8615dc3c6818084c054216034071 |
| lexicon:define-contract | technique | Define Contract | A technique for publishing the operations, shapes and guarantees of a boundary before implementing either side of it. | https://banes-lab.com/json/records/lexicon/define-contract | https://banes-lab.com/records/lexicon/define-contract.md | 12286 | b4be27716122c0dd77715ebd94acf330a4f5b1e15af1f04dec8b77b0b45e4196 |
| lexicon:standardize-the-interface | technique | Standardize the Interface | A technique for giving operations of one kind the same naming, shapes and conventions across a system. | https://banes-lab.com/json/records/lexicon/standardize-the-interface | https://banes-lab.com/records/lexicon/standardize-the-interface.md | 9390 | d8d61d10681eb9ad51f1559dbeaa633ccd380b4e97ecd763d1cefd86771672de |
| lexicon:tolerant-reader | technique | Tolerant Reader | A technique for reading only the fields a consumer needs and ignoring unknown ones, so additive changes do not break it. | https://banes-lab.com/json/records/lexicon/tolerant-reader | https://banes-lab.com/records/lexicon/tolerant-reader.md | 4317 | 8811fc55fad422e377eb892e9c8e9691db0649ec9bffff1e0f09cbf17b86cee8 |
| lexicon:central-orchestrator-bottleneck | anti-pattern | Central Orchestrator Bottleneck | Routing every interaction through one central orchestrator that becomes a bottleneck and single point of failure. | https://banes-lab.com/json/records/lexicon/central-orchestrator-bottleneck | https://banes-lab.com/records/lexicon/central-orchestrator-bottleneck.md | 3688 | 3a3741ae1b6ca43f8268a27be02d53db52de1870573d3f77000905b81942f179 |
| lexicon:centralized-control | anti-pattern | Centralized Control | Concentrating decision-making authority in one place so nodes cannot act independently. | https://banes-lab.com/json/records/lexicon/centralized-control | https://banes-lab.com/records/lexicon/centralized-control.md | 3774 | 53492095904f38b6f4041b0ba4f0a9150cf74ac011bf336691506c28adc2d6ff |
| lexicon:fully-decentralized-control | anti-pattern | Fully Decentralized Control | Leaving control fully decentralized with no central plane, so global runtime policy cannot be coordinated. | https://banes-lab.com/json/records/lexicon/fully-decentralized-control | https://banes-lab.com/records/lexicon/fully-decentralized-control.md | 3313 | 9039b2d993bb6f6422c55e2a95bb8611f741e46e1f651f1bb54e92b8cc43fd49 |
| lexicon:independent-node-decisions | anti-pattern | Independent Node Decisions | Letting each node decide independently with no agreement, so they diverge on shared state. | https://banes-lab.com/json/records/lexicon/independent-node-decisions | https://banes-lab.com/records/lexicon/independent-node-decisions.md | 3655 | 73cf30bcad5f622f3912721b9859af68373cd3507ab02de11c52a9d43a45d703 |
| lexicon:local-only-logs | anti-pattern | Local-Only Logs | Leaving logs scattered on each host with no aggregation, so cross-service analysis is impossible. | https://banes-lab.com/json/records/lexicon/local-only-logs | https://banes-lab.com/records/lexicon/local-only-logs.md | 3723 | fbfbbc387f41056ff7c7148aa1c44d8690dd6b3420397a2c2a75bade8d2359e0 |
| lexicon:pure-choreography | anti-pattern | Pure Choreography | Coordinating a multi-step workflow purely through choreography when central orchestration is needed, scattering its logic. | https://banes-lab.com/json/records/lexicon/pure-choreography | https://banes-lab.com/records/lexicon/pure-choreography.md | 3706 | 69b7e7b9c79fd3d259d5ea4f337e7db35e3416c06a5b656522003dfaa034e3a1 |
| lexicon:scattered-auth-implementations | anti-pattern | Scattered Auth Implementations | Reimplementing authentication separately in each service instead of centralizing it. | https://banes-lab.com/json/records/lexicon/scattered-auth-implementations | https://banes-lab.com/records/lexicon/scattered-auth-implementations.md | 3825 | bd10bdd321b7f5ec9c3cda5ede6079fd5aff8450be4c0e2984b7a79a54b97e10 |
| lexicon:scattered-configuration | anti-pattern | Scattered Configuration | Spreading configuration across many services with no single source, so values drift out of sync. | https://banes-lab.com/json/records/lexicon/scattered-configuration | https://banes-lab.com/records/lexicon/scattered-configuration.md | 4219 | 60d069e873015da2c42c3da02fa7fa6cd9f2575929fb9021a39b1e3620cf1414 |
| lexicon:split-brain-coordination | anti-pattern | Split-Brain Coordination | Two nodes both believing they are leader and acting independently, corrupting shared state. | https://banes-lab.com/json/records/lexicon/split-brain-coordination | https://banes-lab.com/records/lexicon/split-brain-coordination.md | 3773 | ca14fdd851c78f3fc75afae14b2626e578c6b546f3d77220cff2cb7c8ccc9958 |
| lexicon:agreed-single-value-across-nodes | capability | Agreed Single Value Across Nodes | The ability for distributed nodes to agree on a single value despite failures. | https://banes-lab.com/json/records/lexicon/agreed-single-value-across-nodes | https://banes-lab.com/records/lexicon/agreed-single-value-across-nodes.md | 3338 | f4354fabaf40baf38a05d0a0ccc013f3be2ff8bceda5221c23cb893ef0a7550e |
| lexicon:automatic-failover-of-leadership | capability | Automatic Failover of Leadership | The ability to automatically elect a new leader when the current one fails. | https://banes-lab.com/json/records/lexicon/automatic-failover-of-leadership | https://banes-lab.com/records/lexicon/automatic-failover-of-leadership.md | 3967 | 87ed8b8c97b539a48dded2f38cda819ca7394554635bff71708cccd090ccf469 |
| lexicon:central-orchestrator-free-coordination | capability | Central-Orchestrator-Free Coordination | The ability for services to coordinate through events without a central orchestrator. | https://banes-lab.com/json/records/lexicon/central-orchestrator-free-coordination | https://banes-lab.com/records/lexicon/central-orchestrator-free-coordination.md | 3474 | e1b7c596a06650feab1ccc518e19c085462abb782407b79c39e30765422a857e |
| lexicon:centralized-control-of-distributed-runtime | capability | Centralized Control of Distributed Runtime | The ability to manage a distributed runtime's behavior from one central control point. | https://banes-lab.com/json/records/lexicon/centralized-control-of-distributed-runtime | https://banes-lab.com/records/lexicon/centralized-control-of-distributed-runtime.md | 3426 | a7c2359a03a3c8dc456c83557a8be6ec351f59ae27d53b2f224f134b78b0effb |
| lexicon:cross-service-analysis | capability | Cross-Service Analysis | The ability to analyze behavior across services by querying their aggregated logs. | https://banes-lab.com/json/records/lexicon/cross-service-analysis | https://banes-lab.com/records/lexicon/cross-service-analysis.md | 3387 | ac8b011afee61a23c2a1c211cfdb8fce3fad733bfc7111d2444b3287ba297f9e |
| lexicon:independent-ownership | capability | Independent Ownership | The ability for each node or team to own and control its part without central approval. | https://banes-lab.com/json/records/lexicon/independent-ownership | https://banes-lab.com/records/lexicon/independent-ownership.md | 3308 | 34a4a96c2b119b55b5e56159bc5d51f5a03e26b23a221201d3ee4fc36a38355b |
| lexicon:ordered-multi-step-execution | capability | Ordered Multi-Step Execution | The ability to execute the steps of a workflow in a defined order. | https://banes-lab.com/json/records/lexicon/ordered-multi-step-execution | https://banes-lab.com/records/lexicon/ordered-multi-step-execution.md | 3285 | 31f98eebe5cfa535ead07ea598f93a637d46d6e5f4a16f3b231747d14e59009f |
| lexicon:single-writer-coordination | capability | Single-Writer Coordination | The ability to designate one writer for each unit of shared state, whether an elected node or the party a record names, so updates to it need no further coordination. | https://banes-lab.com/json/records/lexicon/single-writer-coordination | https://banes-lab.com/records/lexicon/single-writer-coordination.md | 4235 | 4611b12061b5adb9804e4dc81206dbaaecda12753bf11b4303dd0e45a33e9f73 |
| lexicon:unified-config-management | capability | Unified Config Management | The ability to manage all services' configuration from one place. | https://banes-lab.com/json/records/lexicon/unified-config-management | https://banes-lab.com/records/lexicon/unified-config-management.md | 3307 | 6c380b16b945b69b32e42d5742fcd9da8424131e239650540f782ea1aa5869d8 |
| lexicon:unified-identity | capability | Unified Identity | The ability to give users one identity recognized across all services. | https://banes-lab.com/json/records/lexicon/unified-identity | https://banes-lab.com/records/lexicon/unified-identity.md | 3256 | 73437928f52b7d9280cb999f4a96a4bf4235f5b445b356b8e6e8bdeb288eb4c0 |
| lexicon:config-store | mechanism | Config Store | A central store that holds configuration values for many services to read. | https://banes-lab.com/json/records/lexicon/config-store | https://banes-lab.com/records/lexicon/config-store.md | 3748 | d2b1e337685a9b6e1e11d028597c5114449ce5ad1f5989ae98ee32156e02e436 |
| lexicon:coordinator | mechanism | Coordinator | A component that directs the steps of a multi-service workflow in order. | https://banes-lab.com/json/records/lexicon/coordinator | https://banes-lab.com/records/lexicon/coordinator.md | 3586 | 8e8fa591784b7d4f96b8cec15a448f9e4480f988a4c9aeab8b57a6d531aa4963 |
| lexicon:identity-provider | mechanism | Identity Provider | A central service that authenticates identities and issues credentials for others to trust. | https://banes-lab.com/json/records/lexicon/identity-provider | https://banes-lab.com/records/lexicon/identity-provider.md | 3709 | bfe7d1c0997d6188a3dd687dbd590f2cb433256aa27a28976e1b4aae5355ef06 |
| lexicon:log-aggregation | mechanism | Log Aggregation | A facility that collects logs from many sources into one central store. | https://banes-lab.com/json/records/lexicon/log-aggregation | https://banes-lab.com/records/lexicon/log-aggregation.md | 3636 | 9f91443596235f1ce06caa80d616adcd9f97bcfd540e38bd749e8d3c339332fa |
| lexicon:management-api | mechanism | Management API | A programmatic interface through which operators manage a distributed runtime's state. | https://banes-lab.com/json/records/lexicon/management-api | https://banes-lab.com/records/lexicon/management-api.md | 3902 | 5abb0fbc27b8be97892d4e5ca7100cd436d881819841e2202d02c293f33972e4 |
| lexicon:quorum | constraint | Quorum | The requirement that a majority of nodes agree before a decision commits. | https://banes-lab.com/json/records/lexicon/quorum | https://banes-lab.com/records/lexicon/quorum.md | 3135 | 6461d20f7b48318ca82d43ae1a918738377e0ffe6523cb0f0f01410fde27ba78 |
| lexicon:central-dependency-risk | quality-attribute | Central Dependency Risk | The degree to which centralizing configuration makes the whole system depend on one config source. | https://banes-lab.com/json/records/lexicon/central-dependency-risk | https://banes-lab.com/records/lexicon/central-dependency-risk.md | 4197 | 9b5352991b7654955ecfde13b75ca9a8a577231eafadb9b549e03e94de161fd9 |
| lexicon:centralized-coordinator-coupling | quality-attribute | Centralized Coordinator Coupling | The degree to which routing a workflow through a central coordinator couples participants to it. | https://banes-lab.com/json/records/lexicon/centralized-coordinator-coupling | https://banes-lab.com/records/lexicon/centralized-coordinator-coupling.md | 4216 | e6ab64b22df27c245440c13214bc48c693cd5279e1f3abe627593d9f1042ff69 |
| lexicon:cost-personal-data-exposure | quality-attribute | Cost/Personal Data Exposure | The degree to which aggregating all logs centrally raises storage cost and personal-data exposure. | https://banes-lab.com/json/records/lexicon/cost-personal-data-exposure | https://banes-lab.com/records/lexicon/cost-personal-data-exposure.md | 4293 | 81bc2c28d58b3bd09b879fb3789ecfd85d869a7dd8a1a1b594e79a01e9673e4b |
| lexicon:identity-provider-availability | quality-attribute | Identity Provider Availability | The degree to which every login depends on the central identity provider staying available. | https://banes-lab.com/json/records/lexicon/identity-provider-availability | https://banes-lab.com/records/lexicon/identity-provider-availability.md | 4333 | 3a90637d83158a1c38d96ae4db35f8c50a1f63a04c2e8f0414e2523c01ccd523 |
| lexicon:externalize-configuration | technique | Externalize Configuration | A technique for moving values that vary by environment out of code into configuration read at startup. | https://banes-lab.com/json/records/lexicon/externalize-configuration | https://banes-lab.com/records/lexicon/externalize-configuration.md | 7254 | 16f894c97bb5c0aab15abbbf1cba1707c5bb9d79d457adec268fef2a8b216e45 |
| lexicon:configuration-schema | technique | Configuration Schema | A technique for validating configuration against a declared schema before the system starts. | https://banes-lab.com/json/records/lexicon/configuration-schema | https://banes-lab.com/records/lexicon/configuration-schema.md | 4630 | 082a6bbc7b8547e50baa2cf9121889de6eee69db8fefa7e7e623cd049938dcb8 |
| lexicon:assumption-driven-delivery | anti-pattern | Assumption-Driven Delivery | Shipping on untested assumptions about behavior instead of validating that requirements are met. | https://banes-lab.com/json/records/lexicon/assumption-driven-delivery | https://banes-lab.com/records/lexicon/assumption-driven-delivery.md | 3731 | d54ab4688ca376254975e3a90351295ee09b8e06c06d1d70e183082c5634fc19 |
| lexicon:environment-sensitive-behavior | anti-pattern | Environment-Sensitive Behavior | Behavior that changes with the host environment, so the same run yields different results elsewhere. | https://banes-lab.com/json/records/lexicon/environment-sensitive-behavior | https://banes-lab.com/records/lexicon/environment-sensitive-behavior.md | 3761 | 6ed6c9fdd1bb353fbdd0b23d07dbc19fcb73ff9a45375acd5b57a3564d840065 |
| lexicon:example-only-testing | anti-pattern | Example-Only Testing | Testing only a few hand-picked examples instead of properties that must hold across all inputs. | https://banes-lab.com/json/records/lexicon/example-only-testing | https://banes-lab.com/records/lexicon/example-only-testing.md | 3831 | 4a1a0ca82b23d34bb51ea00e7ba8bcf3200501ccaf25756937a5f44f64780c38 |
| lexicon:floating-dependencies | anti-pattern | Floating Dependencies | Depending on unpinned, floating dependency versions, so builds are not reproducible. | https://banes-lab.com/json/records/lexicon/floating-dependencies | https://banes-lab.com/records/lexicon/floating-dependencies.md | 3674 | dd0673cddf51ba40b00ad09ab22b0d7256196007c3e33261f30d9ba7c836cabb |
| lexicon:hidden-behavior | anti-pattern | Hidden Behavior | Behavior triggered by hidden state or side effects, so outcomes surprise callers. | https://banes-lab.com/json/records/lexicon/hidden-behavior | https://banes-lab.com/records/lexicon/hidden-behavior.md | 3712 | 95f21c565b0c36d84a9ceb801b60332003b6eabf19cf8197b989e7a06981f25c |
| lexicon:hidden-io | anti-pattern | Hidden IO | Performing input/output inside a supposedly pure function, hiding side effects from callers. | https://banes-lab.com/json/records/lexicon/hidden-io | https://banes-lab.com/records/lexicon/hidden-io.md | 3699 | a617192782444ac3e5c37b8fb028a7892c44d0abb0fb8e466108ec18e9f914e0 |
| lexicon:hidden-time-randomness-global-state | anti-pattern | Hidden Time/Randomness/Global State | Reading the clock, randomness, or global state inside a computation, making its output nondeterministic. | https://banes-lab.com/json/records/lexicon/hidden-time-randomness-global-state | https://banes-lab.com/records/lexicon/hidden-time-randomness-global-state.md | 4460 | eeea7648ada3818ec0472b6f211f1e00e201f48503b91ef08d381cda09b24872 |
| lexicon:implementation-only-testing | anti-pattern | Implementation-Only Testing | Testing only against the current implementation's behavior rather than the specified contract. | https://banes-lab.com/json/records/lexicon/implementation-only-testing | https://banes-lab.com/records/lexicon/implementation-only-testing.md | 3948 | a98c23027d430a717602ca25aec3688fb5606f481e64e6b674076272a9fbe48e |
| lexicon:informal-validation-only | anti-pattern | Informal Validation Only | Relying only on informal checks and testing where a formal proof of correctness is warranted. | https://banes-lab.com/json/records/lexicon/informal-validation-only | https://banes-lab.com/records/lexicon/informal-validation-only.md | 3755 | 37593c02c1318cb4e14dd828dc888978d4bc807505cdf2e58d057f5eecad0e98 |
| lexicon:side-effects | anti-pattern | Side Effects | Producing observable side effects in an expression, so it cannot be replaced by its value. | https://banes-lab.com/json/records/lexicon/side-effects | https://banes-lab.com/records/lexicon/side-effects.md | 3739 | a8b0e64b1344a9e48f9f3cea8ee579dca7ebf17630d2e5d9a57ee617a663f017 |
| lexicon:unchecked-dynamic-code | anti-pattern | Unchecked Dynamic Code | Running dynamically generated or evaluated code that static analysis cannot inspect for defects. | https://banes-lab.com/json/records/lexicon/unchecked-dynamic-code | https://banes-lab.com/records/lexicon/unchecked-dynamic-code.md | 5005 | 6ced44a643c1750f1946f17153c58e9cf709ccdef57c814a5486713dedef8549 |
| lexicon:undefined-behavior | anti-pattern | Undefined Behavior | Relying on operations whose result is unspecified, so outcomes vary unpredictably across runs or platforms. | https://banes-lab.com/json/records/lexicon/undefined-behavior | https://banes-lab.com/records/lexicon/undefined-behavior.md | 3695 | 2e6327b8eb74ed60cd47df6ce1a383331c4207d436152eb909bf62b850a830a6 |
| lexicon:untested-implementation | anti-pattern | Untested Implementation | Shipping code with no tests, so its conformance to the specification is unverified. | https://banes-lab.com/json/records/lexicon/untested-implementation | https://banes-lab.com/records/lexicon/untested-implementation.md | 4040 | 4d104d345c20f25697161bd94830aa7aab1060ff64a7d2add6128e4eb0b473c6 |
| lexicon:behavior-validation | capability | Behavior Validation | The ability to confirm a system behaves as its specification requires. | https://banes-lab.com/json/records/lexicon/behavior-validation | https://banes-lab.com/records/lexicon/behavior-validation.md | 3338 | 23e3b094b63ee2e0e6e60fda74e69455d1552ad657ca05f9acd1de87e109c469 |
| lexicon:broad-input-exploration | capability | Broad Input Exploration | The ability to exercise a function across a wide, generated range of inputs. | https://banes-lab.com/json/records/lexicon/broad-input-exploration | https://banes-lab.com/records/lexicon/broad-input-exploration.md | 3310 | b0eeb2099bb3cc3389d2fed148061d647105e94181f672222b83d21b7224b84c |
| lexicon:mathematical-assurance | capability | Mathematical Assurance | The ability to prove mathematically that a system meets its specification. | https://banes-lab.com/json/records/lexicon/mathematical-assurance | https://banes-lab.com/records/lexicon/mathematical-assurance.md | 3284 | b59958e79ef0519b4f55ce4e0e4fa6fa73c520fc612a60b8dbe14512339dfb7a |
| lexicon:regression-safety | capability | Regression Safety | The ability to catch regressions when code changes by re-running tests. | https://banes-lab.com/json/records/lexicon/regression-safety | https://banes-lab.com/records/lexicon/regression-safety.md | 3226 | 43c9f1bc10d6605f5d7acffba289e1c431aa203052bceb30da2f2f43dc22b8e3 |
| lexicon:reliable-automation | capability | Reliable Automation | The ability to automate a process reliably because it repeats identically each run. | https://banes-lab.com/json/records/lexicon/reliable-automation | https://banes-lab.com/records/lexicon/reliable-automation.md | 3216 | a62dedec6453216208d28b11ad995612900168866f103c42064d710d342fd13b |
| lexicon:reliable-testing | capability | Reliable Testing | The ability to test dependably because the same inputs always produce the same outputs. | https://banes-lab.com/json/records/lexicon/reliable-testing | https://banes-lab.com/records/lexicon/reliable-testing.md | 3198 | bda4b76eaf7061e9a3a1e8972946584e453e2a4c6403f000bd37ed08c480a058 |
| lexicon:safe-operation | capability | Safe Operation | The ability to operate without producing incorrect or harmful results. | https://banes-lab.com/json/records/lexicon/safe-operation | https://banes-lab.com/records/lexicon/safe-operation.md | 3148 | 6fce3c8f8f383e4bd982908a5f2647dd426d9ef62ac607e6f47f76d1cb06a6a9 |
| lexicon:safe-sharing | capability | Safe Sharing | The ability to share data freely across threads because it cannot be modified. | https://banes-lab.com/json/records/lexicon/safe-sharing | https://banes-lab.com/records/lexicon/safe-sharing.md | 3203 | d9d779d00e3463af0ebce2bd2f3b56d667cc5f67f56976d97fa12c60f8211bc9 |
| lexicon:specification-compliance | capability | Specification Compliance | The ability to confirm an implementation conforms to its specification. | https://banes-lab.com/json/records/lexicon/specification-compliance | https://banes-lab.com/records/lexicon/specification-compliance.md | 3214 | 21c725ee55469f4849374c3a74f174a9f620bb8127b03af0a3f8248ab93e6db3 |
| lexicon:formal-specification | artifact | Formal Specification | A precise, mathematical statement of what a system must do, against which it is proven. | https://banes-lab.com/json/records/lexicon/formal-specification | https://banes-lab.com/records/lexicon/formal-specification.md | 3243 | d5e71df1de86f3a5055c353e27b0d7d2771a2622c86b1a033baf0170b56ec9b4 |
| lexicon:ruleset | artifact | Ruleset | The set of rules a static analyzer checks source code against. | https://banes-lab.com/json/records/lexicon/ruleset | https://banes-lab.com/records/lexicon/ruleset.md | 3116 | e5a76ba892eb7c97a41e484a279b586645b952da0beb238e4df47b4fc8c17f63 |
| lexicon:tests | artifact | Tests | Executable checks that assert a system behaves as intended. | https://banes-lab.com/json/records/lexicon/tests | https://banes-lab.com/records/lexicon/tests.md | 8799 | f4ecac57b34a6499f2f157b97d0f09f6ff7d70401a228c9a36ac94cfa50c2c94 |
| lexicon:controlled-state | constraint | Controlled State | The requirement that all inputs and state affecting a computation be fixed, bounded or fully specified, so its behavior is reproducible. | https://banes-lab.com/json/records/lexicon/controlled-state | https://banes-lab.com/records/lexicon/controlled-state.md | 3595 | 55b4246ef13396077a1f23656786a07b7d3ff89da30d8e2d12da0e9d15c62057 |
| lexicon:deterministic-behavior | constraint | Deterministic Behavior | The requirement that the code under test produce the same result for the same inputs. | https://banes-lab.com/json/records/lexicon/deterministic-behavior | https://banes-lab.com/records/lexicon/deterministic-behavior.md | 3211 | ab7ea05456816684d5e5d7e3ce0e396dafbea7f107a2f60712fa1b62661491e8 |
| lexicon:no-side-effects | constraint | No Side Effects | The requirement that a function compute its result without observable side effects. | https://banes-lab.com/json/records/lexicon/no-side-effects | https://banes-lab.com/records/lexicon/no-side-effects.md | 3684 | ae1453d45c2bf76e487842bd63f628e4f55e5d1e63c2359490d306f35e575fc8 |
| lexicon:properties-invariants | constraint | Properties/Invariants | The requirement that the general properties or invariants a function must satisfy be defined. | https://banes-lab.com/json/records/lexicon/properties-invariants | https://banes-lab.com/records/lexicon/properties-invariants.md | 3265 | b648fef737db02a00e1f80536451f9607dc0a40e28b2f0dc111394aa41a55ee3 |
| lexicon:value-semantics | constraint | Value Semantics | The requirement that values be compared and copied by content rather than by reference identity. | https://banes-lab.com/json/records/lexicon/value-semantics | https://banes-lab.com/records/lexicon/value-semantics.md | 3229 | 6bb275c8f9f0f9030c61a40b7e564bc4a8375c14d3091561198d75ceb68b409a |
| lexicon:versioned-inputs | constraint | Versioned Inputs | The requirement that all inputs to a build or computation be pinned to specific versions. | https://banes-lab.com/json/records/lexicon/versioned-inputs | https://banes-lab.com/records/lexicon/versioned-inputs.md | 3206 | 82fee52942447d3f4e3a56796a75d78f21a8568b0bd77d87531b3cc4127c8695 |
| lexicon:allocation-cost | quality-attribute | Allocation Cost | The degree of extra memory allocation incurred by creating new immutable values instead of mutating in place. | https://banes-lab.com/json/records/lexicon/allocation-cost | https://banes-lab.com/records/lexicon/allocation-cost.md | 4006 | f580510df7532da08ae7b218dbcff27658163a06d1cca1e60680cad1c2600a55 |
| lexicon:continuous-updates | quality-attribute | Continuous Updates | The degree to which pinning everything for reproducibility conflicts with continuously updating dependencies. | https://banes-lab.com/json/records/lexicon/continuous-updates | https://banes-lab.com/records/lexicon/continuous-updates.md | 4043 | ca74df0bacab25f4e071e0251ba4da6550f7cd462e98b82ebacb46b345f5472a |
| lexicon:cost-complexity | quality-attribute | Cost/Complexity | The degree of cost and complexity added by formally proving a system correct. | https://banes-lab.com/json/records/lexicon/cost-complexity | https://banes-lab.com/records/lexicon/cost-complexity.md | 4084 | 431e24c873fdedf1ed3179a6b7a476510a424346eb651829a787d7d581ecacc0 |
| lexicon:dynamic-runtime-behavior | quality-attribute | Dynamic Runtime Behavior | The degree to which runtime-adaptive behavior undermines a system's predictability. | https://banes-lab.com/json/records/lexicon/dynamic-runtime-behavior | https://banes-lab.com/records/lexicon/dynamic-runtime-behavior.md | 4096 | 15675a16f6ebd40a28701f4ac32d3e417d238dd0e3539ce50aa554f1064e840f |
| lexicon:encapsulation-extremes | quality-attribute | Encapsulation Extremes | The degree to which hiding internals too strictly makes a unit's behavior hard to observe in tests. | https://banes-lab.com/json/records/lexicon/encapsulation-extremes | https://banes-lab.com/records/lexicon/encapsulation-extremes.md | 4074 | cf487e7ceb2cfe185a8b030f7ce093a011812a56a8730265c62e691c81f1d8e2 |
| lexicon:fitness-for-use | quality-attribute | Fitness for Use | The degree to which a product meets the needs of its users. | https://banes-lab.com/json/records/lexicon/fitness-for-use | https://banes-lab.com/records/lexicon/fitness-for-use.md | 3223 | 5d6bbf9e27d07b32a89dd557b76d5047d263387b24daf37a60183f3f1cbe4f90 |
| lexicon:real-world-variability | quality-attribute | Real-World Variability | The degree to which controlling conditions for repeatability diverges from real-world variability. | https://banes-lab.com/json/records/lexicon/real-world-variability | https://banes-lab.com/records/lexicon/real-world-variability.md | 4063 | 84b582b9df1dee2f4f3cc96122c24eca5e7345e9f2ca71a61038e5255c3e65ce |
| lexicon:runtime-adaptivity | quality-attribute | Runtime Adaptivity | The degree to which making behavior deterministic limits adapting dynamically at runtime. | https://banes-lab.com/json/records/lexicon/runtime-adaptivity | https://banes-lab.com/records/lexicon/runtime-adaptivity.md | 4073 | 71744c52b4ccb62694305b3a2f2ed676513c0c9fd22a129ba99056e6dd3d7ca3 |
| lexicon:shrinking-debug-complexity | quality-attribute | Shrinking/Debug Complexity | The degree to which reducing a failing generated case to a minimal example adds debugging complexity. | https://banes-lab.com/json/records/lexicon/shrinking-debug-complexity | https://banes-lab.com/records/lexicon/shrinking-debug-complexity.md | 4197 | f9cb7ee5d6ee1636717b27c107cf03d9a0d779e554d86ac760bcadc49cdde387 |
| lexicon:spec-maintenance | quality-attribute | Spec Maintenance | The degree of ongoing effort to keep a specification current as the system evolves. | https://banes-lab.com/json/records/lexicon/spec-maintenance | https://banes-lab.com/records/lexicon/spec-maintenance.md | 4154 | 8f5d794057297b1f4bd88535d4996a605f662b2fbb25ac0b92c48b55a39dfa2c |
| lexicon:stateful-io | quality-attribute | Stateful IO | The degree to which stateful input/output conflicts with expressions being replaceable by their values. | https://banes-lab.com/json/records/lexicon/stateful-io | https://banes-lab.com/records/lexicon/stateful-io.md | 4089 | 87af7883b477f3b3aa51767ae711a6b28d69cd37ffd96af748df19997d1e5792 |
| lexicon:stateful-operations | quality-attribute | Stateful Operations | The degree to which operations that depend on or mutate state conflict with purity. | https://banes-lab.com/json/records/lexicon/stateful-operations | https://banes-lab.com/records/lexicon/stateful-operations.md | 3986 | 7ad845224e338d4873ac72c32f042ce36424392e8124d4f4e5fcb35643d30511 |
| lexicon:thread-safety | quality-attribute | Thread Safety | The degree to which data can be accessed concurrently without corruption. | https://banes-lab.com/json/records/lexicon/thread-safety | https://banes-lab.com/records/lexicon/thread-safety.md | 3222 | f2adc85b888ff04f6bd2e5b5c887812b3915d79f3b6aad551c62c0c6ac1f5453 |
| lexicon:make-effects-explicit | technique | Make Effects Explicit | A technique for moving input, output and mutation to named boundary operations, so the code between them stays pure. | https://banes-lab.com/json/records/lexicon/make-effects-explicit | https://banes-lab.com/records/lexicon/make-effects-explicit.md | 5922 | 2c90ed64216c83fc56b3a5cd581c3048c7b4e62fdf434d583621bb4ddc3bd24b |
| lexicon:pass-context-explicitly | technique | Pass Context Explicitly | A technique for passing request, user or tenant context as a parameter or scoped object instead of reading it from global state. | https://banes-lab.com/json/records/lexicon/pass-context-explicitly | https://banes-lab.com/records/lexicon/pass-context-explicitly.md | 6740 | c21f381ebc04b90b91eaff3174ed8bc8aee803206f9eb4a01e3727e23adcb896 |
| lexicon:inject-clock-and-randomness | technique | Inject Clock and Randomness | A technique for supplying time and random values through parameters, so the code under test runs the same way every time. | https://banes-lab.com/json/records/lexicon/inject-clock-and-randomness | https://banes-lab.com/records/lexicon/inject-clock-and-randomness.md | 4177 | bfd435ca44d20b770d3b1c3ea9a5f664eaa63b22cda03a60ab43f0dea8f8995a |
| lexicon:test-observable-behavior | technique | Test Observable Behavior | A technique for asserting on a unit's outputs and effects instead of on the internal calls it makes. | https://banes-lab.com/json/records/lexicon/test-observable-behavior | https://banes-lab.com/records/lexicon/test-observable-behavior.md | 3192 | bc5d1faed8d5a4c5d3ce3d7ec8cc449c400873214dd5a2a11db0b4c3a144ccbb |
| lexicon:fake-at-the-boundary | technique | Fake at the Boundary | A technique for replacing an external dependency in tests with a working in-memory implementation of its port. | https://banes-lab.com/json/records/lexicon/fake-at-the-boundary | https://banes-lab.com/records/lexicon/fake-at-the-boundary.md | 4423 | 45b131e3fd2b12b73a3337606a6aa32127a2a47e80f45896d69a77d17403fe5c |
| lexicon:unit-tests | technique | Unit Tests | A technique for testing one unit of behavior in isolation, fast enough to run on every change. | https://banes-lab.com/json/records/lexicon/unit-tests | https://banes-lab.com/records/lexicon/unit-tests.md | 6289 | 3cbfa9420ae3174bd09cbf942e3a20a54751a1d18d787d1db5ce9d156bed29d4 |
| lexicon:component-tests | technique | Component Tests | A technique for testing one deployable component through its public interface with its dependencies replaced. | https://banes-lab.com/json/records/lexicon/component-tests | https://banes-lab.com/records/lexicon/component-tests.md | 4007 | 42b22aff6adb86ce6703b07a504b00e8c78ac592e08a269ba0b6d4ff01d7bdd3 |
| lexicon:isolate-test-state | technique | Isolate Test State | A technique for giving each test its own data and resources, so tests pass in any order. | https://banes-lab.com/json/records/lexicon/isolate-test-state | https://banes-lab.com/records/lexicon/isolate-test-state.md | 3181 | 1b0d15c5d99cca49bb860cfe7b193f561410ac51c1f7fa9349cf6fe8fc17eed3 |
| lexicon:validate-at-the-boundary | technique | Validate at the Boundary | A technique for rejecting malformed input where it enters the system, so the core receives only valid values. | https://banes-lab.com/json/records/lexicon/validate-at-the-boundary | https://banes-lab.com/records/lexicon/validate-at-the-boundary.md | 6952 | 192351ab2ca5723127382c46491349b9986acdbf427800ab89effa5aeadd4865 |
| lexicon:encapsulate-validation | technique | Encapsulate Validation | A technique for placing a value's validation in the type that holds it, so every instance is valid. | https://banes-lab.com/json/records/lexicon/encapsulate-validation | https://banes-lab.com/records/lexicon/encapsulate-validation.md | 3203 | 929b87d861c837fe913888b23879ceeb7ef42af34b03e41bc7f945184dca4410 |
| lexicon:validate-as-a-group | technique | Validate as a Group | A technique for validating fields that depend on each other together, in the object that groups them. | https://banes-lab.com/json/records/lexicon/validate-as-a-group | https://banes-lab.com/records/lexicon/validate-as-a-group.md | 3138 | 26a0d547d29bd3af35c6b6dcb70011d794e2c7f6e1e0b83a06a7f39f874e514b |
| lexicon:precondition-check | technique | Precondition Check | A technique for checking at the start of an operation that the state and arguments it requires hold. | https://banes-lab.com/json/records/lexicon/precondition-check | https://banes-lab.com/records/lexicon/precondition-check.md | 6780 | 6a12e3fec64257dc1c5cc06d23c3a38ab863f4873f9b775c1f7619e6203dd7c5 |
| lexicon:invariant-check | technique | Invariant Check | A technique for checking after each change that the rules a state must always satisfy still hold. | https://banes-lab.com/json/records/lexicon/invariant-check | https://banes-lab.com/records/lexicon/invariant-check.md | 6462 | 8216f26696f20394c74c63931e7bbbbf02d1df1cdce3c853175b51cee5a14c47 |
| lexicon:postcondition-check | technique | Postcondition Check | A technique for checking at the end of an operation that the result and state it promises hold. | https://banes-lab.com/json/records/lexicon/postcondition-check | https://banes-lab.com/records/lexicon/postcondition-check.md | 4009 | 4db5d6748dd33d64deb84238d6bb39a6adb96c77f24d2caae4716c8c88c2058d |
| lexicon:pin-versions | technique | Pin Versions | A technique for recording exact versions of dependencies and tools, so every build uses the same inputs. | https://banes-lab.com/json/records/lexicon/pin-versions | https://banes-lab.com/records/lexicon/pin-versions.md | 3272 | 6da03d2890358079b20c63fb669747c1c308c693f1a6ece5219287fd64756db3 |
| lexicon:ignored-analyzer-findings | anti-pattern | Ignored Analyzer Findings | A defect in which static analysis findings are left unresolved until the analyzer's output stops being read. | https://banes-lab.com/json/records/lexicon/ignored-analyzer-findings | https://banes-lab.com/records/lexicon/ignored-analyzer-findings.md | 3260 | 7c1d8923d53509f0633a03f33c0121f436db0211edae5ec9223a88ddc7378af4 |
| lexicon:platform-migration | capability | Platform Migration | The ability to move a system to a different platform with little or no rework. | https://banes-lab.com/json/records/lexicon/platform-migration | https://banes-lab.com/records/lexicon/platform-migration.md | 3257 | e2b6de52ca9bfa00f2d07f570827fe063d9aeb845cf8535dbb9b5c77d46825e5 |
| lexicon:platform-optimization | quality-attribute | Platform Optimization | The degree to which staying portable across platforms forgoes optimizations specific to any one of them. | https://banes-lab.com/json/records/lexicon/platform-optimization | https://banes-lab.com/records/lexicon/platform-optimization.md | 4090 | e2321478b490ad155008c7918df27c1888ff97ad0274bb924d5b1b34f7770693 |
| lexicon:platform-specific-coupling | anti-pattern | Platform-Specific Coupling | Binding code to one platform's APIs and assumptions, so it cannot run elsewhere without rewriting. | https://banes-lab.com/json/records/lexicon/platform-specific-coupling | https://banes-lab.com/records/lexicon/platform-specific-coupling.md | 3718 | f41bec4e6c77722420b9e590b4eb4c40a2110a2adc3055dd94268afbe0a7619e |
| lexicon:cross-platform-deployment | capability | Cross-Platform Deployment | The ability to deploy the same software unchanged across different operating systems and platforms. | https://banes-lab.com/json/records/lexicon/cross-platform-deployment | https://banes-lab.com/records/lexicon/cross-platform-deployment.md | 3351 | fc84e5b97f307eaf5d82d54e925ff24ec4e49383b30ce39cc70c4afe432784bf |
| lexicon:native-optimization | quality-attribute | Native Optimization | The degree to which staying platform-independent forgoes optimizations native to a specific platform. | https://banes-lab.com/json/records/lexicon/native-optimization | https://banes-lab.com/records/lexicon/native-optimization.md | 4159 | cfd4f7123f3157ca9dff06e53bdc66aff9debd9c15821d81e78d4d2b16fecd4f |
| lexicon:os-vendor-lock-in | anti-pattern | OS/Vendor Lock-In | Depending on one operating system or vendor's proprietary features, so switching away becomes costly or impossible. | https://banes-lab.com/json/records/lexicon/os-vendor-lock-in | https://banes-lab.com/records/lexicon/os-vendor-lock-in.md | 3764 | af2794419a64c9b6ef361c072760c2cda052f7bf03e3e5108952d6a7ec17aab4 |
| lexicon:platform-abstraction | constraint | Platform Abstraction | The requirement that platform-specific details sit behind an abstraction the rest of the system depends on. | https://banes-lab.com/json/records/lexicon/platform-abstraction | https://banes-lab.com/records/lexicon/platform-abstraction.md | 3295 | 355760b767a2c372a8be2196c02759be9c58c38dac136ddba7272338a9186d12 |
| lexicon:reliable-deployment | capability | Reliable Deployment | The ability to deploy with confidence because every environment behaves the same way. | https://banes-lab.com/json/records/lexicon/reliable-deployment | https://banes-lab.com/records/lexicon/reliable-deployment.md | 3283 | 3efa8b9301880b0830f19c66657c6cea40aff72fa33aa19b0e6734dd34c908de |
| lexicon:snowflake-environments | anti-pattern | Snowflake Environments | Environments each configured by hand into unique, unreproducible states, so what works in one fails in another. | https://banes-lab.com/json/records/lexicon/snowflake-environments | https://banes-lab.com/records/lexicon/snowflake-environments.md | 3745 | 5277a76928df565b1cb22c79341dcc609348f1e64a9aad310189773dac1c4ff1 |
| lexicon:externalized-config | constraint | Externalized Config | The requirement that configuration live outside the container image so one image runs in any environment. | https://banes-lab.com/json/records/lexicon/externalized-config | https://banes-lab.com/records/lexicon/externalized-config.md | 3309 | ebeb8aff5509e2209bd75412515ba261c11a33058fc68820706d072e63cfff73 |
| lexicon:host-coupled-deployment | anti-pattern | Host-Coupled Deployment | Deploying software that depends on specifics of its host machine, so it cannot be moved or reproduced elsewhere. | https://banes-lab.com/json/records/lexicon/host-coupled-deployment | https://banes-lab.com/records/lexicon/host-coupled-deployment.md | 3715 | db35759fc703fbbf34f830a1944637dd320a4568792802807eadf87fe6b4dba5 |
| lexicon:image-complexity | quality-attribute | Image Complexity | The degree to which packaging everything into a container image grows the image and its maintenance burden. | https://banes-lab.com/json/records/lexicon/image-complexity | https://banes-lab.com/records/lexicon/image-complexity.md | 4073 | 23abcf7b78ab28bb61e859a0d1ce1d4b9d1b5d383f9f2712397ef99c43a304de |
| lexicon:image-definition | artifact | Image Definition | A declarative file specifying how a container image is built from a base and its dependencies. | https://banes-lab.com/json/records/lexicon/image-definition | https://banes-lab.com/records/lexicon/image-definition.md | 3279 | 1ac4e828ec7cbc8fda9dd27a164d651fd7d0ef9fc1683f4df69d328f90688553 |
| lexicon:repeatable-runtime-packaging | capability | Repeatable Runtime Packaging | The ability to package an application and its runtime into one reproducible, portable unit. | https://banes-lab.com/json/records/lexicon/repeatable-runtime-packaging | https://banes-lab.com/records/lexicon/repeatable-runtime-packaging.md | 3295 | 067daa08e24b03160eb0f4cb3a54d279e3837fa4e1f40b3aa5128bf05a6b19f2 |
| lexicon:automated-provisioning | capability | Automated Provisioning | The ability to create and configure infrastructure automatically from declarative definitions. | https://banes-lab.com/json/records/lexicon/automated-provisioning | https://banes-lab.com/records/lexicon/automated-provisioning.md | 3399 | 6da492cd40d5d7684c966f954c84a80c83d2c6cef201ecbda86264be61e51af0 |
| lexicon:manual-infrastructure-changes | anti-pattern | Manual Infrastructure Changes | Changing infrastructure by hand instead of through code, so its state is undocumented and unreproducible. | https://banes-lab.com/json/records/lexicon/manual-infrastructure-changes | https://banes-lab.com/records/lexicon/manual-infrastructure-changes.md | 3802 | 35cc5f1f6c6359e03b3d6c203852baf196482c1da57168eec083b7b9366f2630 |
| lexicon:version-control | mechanism | Version Control | A system that records changes to files over time so any version can be recovered, compared, or audited. | https://banes-lab.com/json/records/lexicon/version-control | https://banes-lab.com/records/lexicon/version-control.md | 3335 | 6fdc8819da3f5510dd50127ee56afd4507850d0dd0c5f0452a748c15bbeeaace |
| lexicon:applicable-standard | constraint | Applicable Standard | The requirement that the relevant external standard a system must meet be identified and adhered to. | https://banes-lab.com/json/records/lexicon/applicable-standard | https://banes-lab.com/records/lexicon/applicable-standard.md | 3309 | d07c0c359c913fea8596471cc7d6e332ae786483e12cc3c1992b00ecba08493c |
| lexicon:certification-compatibility | capability | Certification/Compatibility | The ability to certify a system and interoperate with others by conforming to a shared standard. | https://banes-lab.com/json/records/lexicon/certification-compatibility | https://banes-lab.com/records/lexicon/certification-compatibility.md | 3331 | 7e6f0ad5584f400e6b0187699d6af14e71e46b24efc0218f4da3b26e1f769c8f |
| lexicon:innovation-flexibility | quality-attribute | Innovation/Flexibility | The degree to which conforming to an external standard limits the freedom to innovate beyond it. | https://banes-lab.com/json/records/lexicon/innovation-flexibility | https://banes-lab.com/records/lexicon/innovation-flexibility.md | 4201 | 2a5c58673be8e4ea4f7a33da3ad4ab52bda2beb488cc270ec10f42940ebf9b4a |
| lexicon:proprietary-deviation | anti-pattern | Proprietary Deviation | Deviating from a shared standard with proprietary extensions, breaking interoperability with conformant systems. | https://banes-lab.com/json/records/lexicon/proprietary-deviation | https://banes-lab.com/records/lexicon/proprietary-deviation.md | 3802 | 81bcda18e1d6a9853b643ab4489dddf236d52a6c7c44bd2b3404551581dd616e |
| lexicon:adapter-port-abstraction | pattern | Adapter/Port Abstraction | A boundary abstraction separating core logic from external protocols via port interfaces and pluggable adapters. | https://banes-lab.com/json/records/lexicon/adapter-port-abstraction | https://banes-lab.com/records/lexicon/adapter-port-abstraction.md | 3303 | 3cb7761bb6c8f0f128cd6d9b627803cece6d47b63d1e728e907f01b2038c0417 |
| lexicon:protocol-swap | capability | Protocol Swap | The ability to switch the transport or wire protocol without changing core domain logic. | https://banes-lab.com/json/records/lexicon/protocol-swap | https://banes-lab.com/records/lexicon/protocol-swap.md | 3332 | 057487071cae94767ee22b5f114fabf27f9439350b7757e1fff3eff96812add6 |
| lexicon:protocol-coupled-domain-logic | anti-pattern | Protocol-Coupled Domain Logic | Domain logic written directly against a specific protocol, so changing the protocol means rewriting the core. | https://banes-lab.com/json/records/lexicon/protocol-coupled-domain-logic | https://banes-lab.com/records/lexicon/protocol-coupled-domain-logic.md | 3806 | 048c3900941ca62c243c7658c3a24509ab8ffedf11076813dc85cd6a4a248dbb |
| lexicon:protocol-specific-features | quality-attribute | Protocol-Specific Features | The degree to which staying protocol-independent forgoes features unique to any one protocol. | https://banes-lab.com/json/records/lexicon/protocol-specific-features | https://banes-lab.com/records/lexicon/protocol-specific-features.md | 4214 | a34edc82db61cc46a333be29052be8dfb5b39f0874f73aac30382ee24bb9d0aa |
| lexicon:config-schema | artifact | Config Schema | A schema defining the structure, types, and defaults of a system's externalized configuration. | https://banes-lab.com/json/records/lexicon/config-schema | https://banes-lab.com/records/lexicon/config-schema.md | 3307 | 1f58349ce3d0e65f84b3eac8c23a792e1eba8d83236ec6f330b387b06dcef349 |
| lexicon:config-sprawl | quality-attribute | Config Sprawl | The degree to which externalizing configuration across many sources scatters it and makes it hard to track. | https://banes-lab.com/json/records/lexicon/config-sprawl | https://banes-lab.com/records/lexicon/config-sprawl.md | 4201 | a8825935aafc1065b7359d9e2de6d0a4c6090cbde79bbb344f6bbc273a1b275f |
| lexicon:environment-specific-deployment | capability | Environment-Specific Deployment | The ability to deploy one build into different environments by supplying environment-specific configuration. | https://banes-lab.com/json/records/lexicon/environment-specific-deployment | https://banes-lab.com/records/lexicon/environment-specific-deployment.md | 3374 | cad00fd4bcab51be1da08ce093a67df6a9c8d6c9c7261c74c9c5add67c8d9cac |
| lexicon:secure-config-handling | constraint | Secure Config Handling | The requirement that secrets and sensitive configuration be stored and injected securely, never hardcoded. | https://banes-lab.com/json/records/lexicon/secure-config-handling | https://banes-lab.com/records/lexicon/secure-config-handling.md | 3372 | e5b1081601f9c08ae2f4e73e14ff5bb8b2cb36c8686ec57cd9657050d38e187f |
| lexicon:deploy-time | quality-attribute | Deploy Time | The degree to which replacing whole instances rather than patching them in place lengthens deployment time. | https://banes-lab.com/json/records/lexicon/deploy-time | https://banes-lab.com/records/lexicon/deploy-time.md | 4138 | 64896b7aff81f8de2d7ffb2f7e55e15497e66734936b44df5bb8a79a76f5371f |
| lexicon:deterministic-redeploys | capability | Deterministic Redeploys | The ability to redeploy infrastructure identically every time from one fixed definition. | https://banes-lab.com/json/records/lexicon/deterministic-redeploys | https://banes-lab.com/records/lexicon/deterministic-redeploys.md | 3297 | 276c2037678ab2de907d798ac255ac68ff7595180a8247138c7034901ecb0245 |
| lexicon:in-place-server-mutation | anti-pattern | In-Place Server Mutation | Modifying running servers in place over time, so their state drifts and can no longer be reproduced. | https://banes-lab.com/json/records/lexicon/in-place-server-mutation | https://banes-lab.com/records/lexicon/in-place-server-mutation.md | 3897 | 4fc42bf9644bd40369dce398e0c731cd6bfab898501614c9f5ce90a99b24496b |
| lexicon:instance-replacement-over-mutation | capability | Instance Replacement over Mutation | The ability to update infrastructure by replacing instances wholesale rather than mutating them in place. | https://banes-lab.com/json/records/lexicon/instance-replacement-over-mutation | https://banes-lab.com/records/lexicon/instance-replacement-over-mutation.md | 3980 | 4c4899d46507e32b33a150ec6f85ef72f72e3733847667197d8bc90252785644 |
| lexicon:centralized-runtime-control | anti-pattern | Centralized Runtime Control | Concentrating runtime control in one place so otherwise-independent modules cannot act without it. | https://banes-lab.com/json/records/lexicon/centralized-runtime-control | https://banes-lab.com/records/lexicon/centralized-runtime-control.md | 3187 | 92ca61260b2f92b04e4bd6f26849125c163fb2a832d4282864c14ca365ebe05d |
| lexicon:context-specific-coupling | anti-pattern | Context-Specific Coupling | Baking one caller's specific assumptions into a component, preventing its reuse elsewhere. | https://banes-lab.com/json/records/lexicon/context-specific-coupling | https://banes-lab.com/records/lexicon/context-specific-coupling.md | 3543 | 265b7e4b04a6b20c898599c6ec194c2afed0ceb4f0652a3178f949a97ae554e5 |
| lexicon:copy-paste-programming | anti-pattern | Copy-Paste Programming | Duplicating code by copying and pasting instead of extracting a shared abstraction. | https://banes-lab.com/json/records/lexicon/copy-paste-programming | https://banes-lab.com/records/lexicon/copy-paste-programming.md | 3555 | 0566db061540e0090e4dd22a8d11e626cbd16fab7eca0be89b28a8701a427ce8 |
| lexicon:cross-cutting-leakage | anti-pattern | Cross-Cutting Leakage | Letting a concern such as logging or security bleed into unrelated modules throughout the code. | https://banes-lab.com/json/records/lexicon/cross-cutting-leakage | https://banes-lab.com/records/lexicon/cross-cutting-leakage.md | 3175 | 1a6f78c37e12c3268ecec5d3e7c02d9f861a729188e6154b2f58d7b9c5b45f2e |
| lexicon:deep-inheritance-hierarchy | anti-pattern | Deep Inheritance Hierarchy | Stacking many layers of subclassing, so behavior is scattered and fragile to change. | https://banes-lab.com/json/records/lexicon/deep-inheritance-hierarchy | https://banes-lab.com/records/lexicon/deep-inheritance-hierarchy.md | 3656 | 90fa1e97fa3f95345d822de1fea080e9fef0d6725a78a93514bc449a6247ba2c |
| lexicon:exposed-internals | anti-pattern | Exposed Internals | Making a module's internal fields and workings reachable from outside, whether public outright or through trivial getters and setters, so callers depend on details that should be hidden and its invariants go unprotected. | https://banes-lab.com/json/records/lexicon/exposed-internals | https://banes-lab.com/records/lexicon/exposed-internals.md | 6918 | 9a360074074d8ca0458e067771e2ad47576cd7ef4036f6b04a9d1e2d34736538 |
| lexicon:implementation-specific-contracts | anti-pattern | Implementation-Specific Contracts | Defining an interface around one implementation's quirks, so no alternative can satisfy it. | https://banes-lab.com/json/records/lexicon/implementation-specific-contracts | https://banes-lab.com/records/lexicon/implementation-specific-contracts.md | 3921 | a61e62639e128d6dc24580fbd01a6b3f795d3bcc5e585577acbf154bd38c5583 |
| lexicon:leaky-abstraction | anti-pattern | Leaky Abstraction | An abstraction that forces callers to understand its underlying implementation to use it correctly. | https://banes-lab.com/json/records/lexicon/leaky-abstraction | https://banes-lab.com/records/lexicon/leaky-abstraction.md | 3910 | b4430dd9dbd8bd62088f35100f60c742fb40c719ae28f94b568a5bb5fbfe3444 |
| lexicon:mixed-layers | anti-pattern | Mixed Layers | Interleaving different architectural layers' logic in one place instead of keeping each concern separate. | https://banes-lab.com/json/records/lexicon/mixed-layers | https://banes-lab.com/records/lexicon/mixed-layers.md | 4009 | b790069156aab8e2d21776db02b40dcdb220ed39ed1d50997d3748c854fb9c2f |
| lexicon:monolithic-procedures | anti-pattern | Monolithic Procedures | Writing large all-in-one procedures that cannot be recombined from smaller, independent parts. | https://banes-lab.com/json/records/lexicon/monolithic-procedures | https://banes-lab.com/records/lexicon/monolithic-procedures.md | 3074 | 7b9df620010287e5f09f923c7cbb59008bdd9b39ae0474c639e231ee6c0a86df |
| lexicon:shared-runtime-dependency | anti-pattern | Shared Runtime Dependency | Coupling supposedly-independent modules through a shared runtime component they all depend on. | https://banes-lab.com/json/records/lexicon/shared-runtime-dependency | https://banes-lab.com/records/lexicon/shared-runtime-dependency.md | 3075 | cf1da2b8cc54b26e61aae392189059d4871f4ab8d91061ed66a88cdc3456430d |
| lexicon:tight-coupling | anti-pattern | Tight Coupling | Binding components so closely that a change in one forces changes in the others. | https://banes-lab.com/json/records/lexicon/tight-coupling | https://banes-lab.com/records/lexicon/tight-coupling.md | 3504 | 62f7a9d44a0bc1286fe3bbc8a6b15aa3b8443c26d1cf27dcc2423e24ce7e9cd4 |
| lexicon:bounded-context-ownership | capability | Bounded Context Ownership | The ability for a team or module to own and control one bounded part of the system. | https://banes-lab.com/json/records/lexicon/bounded-context-ownership | https://banes-lab.com/records/lexicon/bounded-context-ownership.md | 3445 | b00764fb6ab935412b8d44983e1cc86818e22dee617ad5fb1f1670435deeb519 |
| lexicon:change-isolation | capability | Change Isolation | The ability to confine the impact of a change behind a boundary so callers are unaffected. | https://banes-lab.com/json/records/lexicon/change-isolation | https://banes-lab.com/records/lexicon/change-isolation.md | 3083 | 3876d93cd46947260da1cec6e4891f92109295d57812a8ebefeea93108bc5002 |
| lexicon:independent-testing | capability | Independent Testing | The ability to test a component in isolation without standing up its collaborators. | https://banes-lab.com/json/records/lexicon/independent-testing | https://banes-lab.com/records/lexicon/independent-testing.md | 3840 | eab1f8646b558bdd8cc5502050f7c7a40f317d7e6dfeb4a34a283b3e2958efb2 |
| lexicon:internal-refactoring | capability | Internal Refactoring | The ability to rework a module's internals freely as long as its interface stays stable. | https://banes-lab.com/json/records/lexicon/internal-refactoring | https://banes-lab.com/records/lexicon/internal-refactoring.md | 3097 | 5636fe5a64422d79c4ff914f39feb8cd3fc6e81a2c0601ea73b8ad9543dc485d |
| lexicon:invariant-protection | capability | Invariant Protection | The ability to guarantee an object's rules always hold by controlling all access to its state. | https://banes-lab.com/json/records/lexicon/invariant-protection | https://banes-lab.com/records/lexicon/invariant-protection.md | 3496 | 8dc90c780fd9c16a09d4297ddf1293c171c4aa06683143d0ef7d70ba23f326b4 |
| lexicon:product-lines | capability | Product Lines | The ability to build a family of related products from shared, reusable components. | https://banes-lab.com/json/records/lexicon/product-lines | https://banes-lab.com/records/lexicon/product-lines.md | 3462 | 112b810306fed13f4c682a2667bb8769f97c4dcd24147124da611aefeb6c758d |
| lexicon:shared-libraries | capability | Shared Libraries | The ability to factor common functionality into libraries reused across projects. | https://banes-lab.com/json/records/lexicon/shared-libraries | https://banes-lab.com/records/lexicon/shared-libraries.md | 2974 | d5173d34d2ba5f0c72eb9f60421e8c93c30061294ff9b7fdb0e27198344a0eb7 |
| lexicon:strategy-swap | capability | Strategy Swap | The ability to replace one interchangeable algorithm or implementation, such as a plugin at a declared seam, with another without modifying its host. | https://banes-lab.com/json/records/lexicon/strategy-swap | https://banes-lab.com/records/lexicon/strategy-swap.md | 3981 | 2d1c1bed1aa5e2735764d25c856cc8b0a327233eda6604c5bbe94e69aa71310a |
| lexicon:vendor-swap | capability | Vendor Swap | The ability to replace one vendor's implementation with another behind a stable interface. | https://banes-lab.com/json/records/lexicon/vendor-swap | https://banes-lab.com/records/lexicon/vendor-swap.md | 2963 | 45728e91dc640001fb30c7cba9316b0d468159e7ba91e89c024899a9b49480d3 |
| lexicon:delegation | technique | Delegation | Forwarding work to a contained collaborator object rather than inheriting the behavior. | https://banes-lab.com/json/records/lexicon/delegation | https://banes-lab.com/records/lexicon/delegation.md | 3051 | 82c416bdbba06af5fc42d70712dac3f7a38d7a5434c687d9c84d4145b317924c |
| lexicon:deep-optimization | activity | Deep Optimization | The practice of optimizing heavily against a specific implementation's traits, which ties code to it. | https://banes-lab.com/json/records/lexicon/deep-optimization | https://banes-lab.com/records/lexicon/deep-optimization.md | 3749 | 873b76d92b085fc6d4d2f24a204b389ce3c3c04036aca75d35419735ceeb8ef2 |
| lexicon:yagni | principle | YAGNI | You Aren't Gonna Need It: build only what current requirements demand and defer speculative generality. | https://banes-lab.com/json/records/lexicon/yagni | https://banes-lab.com/records/lexicon/yagni.md | 3738 | beada92c22f3d7172480c448ecd02202064cd53a9f24d893998fa9f2f8f32dcd |
| lexicon:canonical-source | constraint | Canonical Source | The requirement that each piece of knowledge have one authoritative definition rather than copies. | https://banes-lab.com/json/records/lexicon/canonical-source | https://banes-lab.com/records/lexicon/canonical-source.md | 3020 | c9f3419d7cd08c8fe1e303b0751fe50d4b73d8961fd774e34839f2c52ce271c9 |
| lexicon:contract-compatibility | constraint | Contract Compatibility | The requirement that every alternative implementation fully honor the same interface contract. | https://banes-lab.com/json/records/lexicon/contract-compatibility | https://banes-lab.com/records/lexicon/contract-compatibility.md | 3588 | bc6aaeeb066148b0fb0e1731d712cceddc3dc5cced903276a7bcb843609083a4 |
| lexicon:explicit-interfaces | constraint | Explicit Interfaces | The requirement that a module interact only through declared interfaces, not its hidden internals. | https://banes-lab.com/json/records/lexicon/explicit-interfaces | https://banes-lab.com/records/lexicon/explicit-interfaces.md | 3119 | 0b6e9f6c12c3f8e9748d34c6e68766d8de19d6f58264e66699a35b58988270a1 |
| lexicon:interface-definition | constraint | Interface Definition | The requirement that an abstraction expose a defined interface separate from its implementation. | https://banes-lab.com/json/records/lexicon/interface-definition | https://banes-lab.com/records/lexicon/interface-definition.md | 3499 | 87d5e06dfae05f9f8af88b5df84f6405d30edf1784d45e4827ae09f2331fc2ec |
| lexicon:stable-semantics | constraint | Stable Semantics | The requirement that an abstraction's meaning stay consistent even as its implementations change. | https://banes-lab.com/json/records/lexicon/stable-semantics | https://banes-lab.com/records/lexicon/stable-semantics.md | 3046 | ca773dda3dc27831b008481aeb1532fa38241888b7d3f457ac91b0bbcb96e6a3 |
| lexicon:coordination-cost | quality-attribute | Coordination Cost | The degree of extra coordination required when components are made fully independent. | https://banes-lab.com/json/records/lexicon/coordination-cost | https://banes-lab.com/records/lexicon/coordination-cost.md | 3842 | 54a2ad40e2ee475bc73943aa83b58ef959743f1d24f2e6dc116600287df6ea33 |
| lexicon:excessive-fragmentation | quality-attribute | Excessive Fragmentation | The degree to which splitting responsibilities too finely scatters logic across many small units. | https://banes-lab.com/json/records/lexicon/excessive-fragmentation | https://banes-lab.com/records/lexicon/excessive-fragmentation.md | 4541 | 3ba66a48a40b5615953c3308f55cc13573e9fb9666557c169a192270302997c6 |
| lexicon:locality-of-behavior | quality-attribute | Locality of Behavior | The degree to which keeping related behavior together can conflict with removing all duplication. | https://banes-lab.com/json/records/lexicon/locality-of-behavior | https://banes-lab.com/records/lexicon/locality-of-behavior.md | 5381 | 573be8289aa74cf5df559a88662ed7ac9ddd5bca2105f52e860f152f18f8dd24 |
| lexicon:over-generalization | quality-attribute | Over-Generalization | The degree to which making code reusable for every case adds abstraction that harms clarity. | https://banes-lab.com/json/records/lexicon/over-generalization | https://banes-lab.com/records/lexicon/over-generalization.md | 3827 | 3e8f78188439a28f8589d3fa376622efbe43d30d3f3912eb2ca4dbfbfb452222 |
| lexicon:over-layering | quality-attribute | Over-Layering | The degree to which adding separating layers introduces indirection that outweighs the separation gained. | https://banes-lab.com/json/records/lexicon/over-layering | https://banes-lab.com/records/lexicon/over-layering.md | 4392 | 52fc1a2cd3f4f40647bc4d742e0ed43ed22dadd66408e34be502e6d6b12ad029 |
| lexicon:over-specialization | quality-attribute | Over-Specialization | The degree to which pursuing tight cohesion can narrow a unit's purpose too far to reuse. | https://banes-lab.com/json/records/lexicon/over-specialization | https://banes-lab.com/records/lexicon/over-specialization.md | 3844 | dbd13505dab8ed6881ebc0d4b3f2fd8ae3fca373804a4e6797760af360b29bc5 |
| lexicon:performance-overhead | quality-attribute | Performance Overhead | The degree of runtime cost added by composing behavior from many small, indirected parts. | https://banes-lab.com/json/records/lexicon/performance-overhead | https://banes-lab.com/records/lexicon/performance-overhead.md | 3923 | e1c01e503fe7fec385a9239c909e56e21713cae7880fc9ecbdfde19bab79c11d |
| lexicon:simplicity-for-trivial-reuse | quality-attribute | Simplicity for Trivial Reuse | The degree to which composition adds wiring that inheritance would make simpler for trivial reuse. | https://banes-lab.com/json/records/lexicon/simplicity-for-trivial-reuse | https://banes-lab.com/records/lexicon/simplicity-for-trivial-reuse.md | 4139 | fec226d4e76fdf65c102345d8c886c67e4be676cd4b20b9d33adbca4a2ad4876 |
| lexicon:specialized-optimization | quality-attribute | Specialized Optimization | The degree to which optimizing for one implementation undermines the ability to swap implementations. | https://banes-lab.com/json/records/lexicon/specialized-optimization | https://banes-lab.com/records/lexicon/specialized-optimization.md | 3991 | 2da86ddf969e1407b56d10a5b65a181eadfa6c8cbe57aa4ba6548b9f4a0a3598 |
| lexicon:extract-class | technique | Extract Class | A technique for moving a cohesive group of fields and methods out of a class into a new class of their own. | https://banes-lab.com/json/records/lexicon/extract-class | https://banes-lab.com/records/lexicon/extract-class.md | 4584 | a3b93e85657a6ef8aa1d7c559486bd3f6167d123f7a3d721e3b6caf6280c0afb |
| lexicon:extract-module | technique | Extract Module | A technique for moving one responsibility out of a module into a new module with its own entry point. | https://banes-lab.com/json/records/lexicon/extract-module | https://banes-lab.com/records/lexicon/extract-module.md | 7428 | ec1dec0532aa394ed0e2ecba2636f0368be926cdcf2c18ff6273ae41d4c617aa |
| lexicon:split-module | technique | Split Module | A technique for dividing a module into modules that each hold one reason to change. | https://banes-lab.com/json/records/lexicon/split-module | https://banes-lab.com/records/lexicon/split-module.md | 5463 | d83e5ae9fef3c034a03d0639556bc895852f1ba377572a9eeb702fe231250f21 |
| lexicon:move-behavior-to-its-owner | technique | Move Behavior to Its Owner | A technique for moving a method or function to the module that owns the data it reads and writes. | https://banes-lab.com/json/records/lexicon/move-behavior-to-its-owner | https://banes-lab.com/records/lexicon/move-behavior-to-its-owner.md | 8134 | 10a323a37ac726b332672d32bb962db045a0a4b559599397a0cf7ab0a8563cb6 |
| lexicon:extract-function | technique | Extract Function | A technique for moving a fragment of a long function into a named function of its own. | https://banes-lab.com/json/records/lexicon/extract-function | https://banes-lab.com/records/lexicon/extract-function.md | 3410 | b6a4633f3fe002233e7300c6752b21ccb6e785158537cfec1e18186af602073b |
| lexicon:split-method | technique | Split Method | A technique for dividing a method that branches on a flag into one method per behavior. | https://banes-lab.com/json/records/lexicon/split-method | https://banes-lab.com/records/lexicon/split-method.md | 2977 | 8d81866cd844140ab647dcc1d0e936cc5ec5f482f8421bfc52e31ebcd39891b1 |
| lexicon:inline-abstraction | technique | Inline Abstraction | A technique for removing an interface, layer or wrapper that adds no policy and calling its single implementation directly. | https://banes-lab.com/json/records/lexicon/inline-abstraction | https://banes-lab.com/records/lexicon/inline-abstraction.md | 4137 | ae01480d6fedcb4175a3367a35408028946aa2ca8c68a71df773cd1d863ffe8b |
| lexicon:hide-delegate | technique | Hide Delegate | A technique for adding a method on an object that forwards to the object behind it, so clients stop navigating the chain. | https://banes-lab.com/json/records/lexicon/hide-delegate | https://banes-lab.com/records/lexicon/hide-delegate.md | 3025 | 3e5342a262743e0cb29f0d4c29634e6d327ca66ed052e58f8eeb3ef19810026b |
| lexicon:encapsulate-state | technique | Encapsulate State | A technique for making a module's state private and exposing only operations that keep its rules. | https://banes-lab.com/json/records/lexicon/encapsulate-state | https://banes-lab.com/records/lexicon/encapsulate-state.md | 7186 | 38b5ae12febfed3cb2c141fcf18421085d8216e2ef81aefabeadf2d7efab1cd7 |
| lexicon:restrict-exports | technique | Restrict Exports | A technique for narrowing a module's public surface to the operations its consumers need. | https://banes-lab.com/json/records/lexicon/restrict-exports | https://banes-lab.com/records/lexicon/restrict-exports.md | 8042 | 17bd092f4f127e56b6c8ce5fb7e55001dcb5c39b8266bdbf474529119a07471e |
| lexicon:introduce-parameter-object | technique | Introduce Parameter Object | A technique for replacing a group of parameters that travel together with one named object. | https://banes-lab.com/json/records/lexicon/introduce-parameter-object | https://banes-lab.com/records/lexicon/introduce-parameter-object.md | 4623 | e8e5d83fac26c3fd502d40dd788bba2e23051b06b9a97efda1c8a9eeba69e099 |
| lexicon:separate-query-from-command | technique | Separate Query from Command | A technique for splitting an operation that both returns data and changes state into a query and a command. | https://banes-lab.com/json/records/lexicon/separate-query-from-command | https://banes-lab.com/records/lexicon/separate-query-from-command.md | 4039 | f2b81ab1909b2d860a63e02ee62af67bafd7d6e76d8273aa45a8fcea4df675e9 |
| lexicon:collapse-layers | technique | Collapse Layers | A technique for merging layers that only pass calls through, so a simple operation crosses fewer boundaries. | https://banes-lab.com/json/records/lexicon/collapse-layers | https://banes-lab.com/records/lexicon/collapse-layers.md | 3475 | 67efb7935e3f8606021769e07652fbf1c4bca5f8a8cb248d8bfb004ea2ffec84 |
| lexicon:preserve-only-real-boundaries | technique | Preserve Only Real Boundaries | A technique for keeping an abstraction only where it separates parts that change for different reasons. | https://banes-lab.com/json/records/lexicon/preserve-only-real-boundaries | https://banes-lab.com/records/lexicon/preserve-only-real-boundaries.md | 3061 | ea334c97846f9bb714d1a648a4610002d81893b52f17eacedc6030b91f86b8ee |
| lexicon:split-by-domain | technique | Split by Domain | A technique for dividing a catch-all module into modules named for the domain concepts they serve. | https://banes-lab.com/json/records/lexicon/split-by-domain | https://banes-lab.com/records/lexicon/split-by-domain.md | 3070 | 9a4d978f9076fef8b199420e85e5a002e601a03df44a84477f26e532ea86aada |
| lexicon:centralize-the-rule | technique | Centralize the Rule | A technique for gathering every copy of one rule into a single definition that the copies are replaced by. | https://banes-lab.com/json/records/lexicon/centralize-the-rule | https://banes-lab.com/records/lexicon/centralize-the-rule.md | 6554 | 5c24043837d2fdfd195d08b8a4b335d374c49ce0a5fa1cfe1a993c25eb5dee2b |
| lexicon:explicit-dependency | technique | Explicit Dependency | A technique for declaring what a module needs as parameters or imports instead of reaching it through global state. | https://banes-lab.com/json/records/lexicon/explicit-dependency | https://banes-lab.com/records/lexicon/explicit-dependency.md | 4462 | ef7bf2a351e5db1e03378fb155fc720618f118342237371b17a1568806ff6030 |
| lexicon:localize-effect | technique | Localize Effect | A technique for confining a change of global behavior to the scope that needs it. | https://banes-lab.com/json/records/lexicon/localize-effect | https://banes-lab.com/records/lexicon/localize-effect.md | 3068 | 5afe17be937293c4ae0e3cdc693813c484f65a4b289afd101aea6de58501eeec |
| lexicon:restrict-global-mutation | technique | Restrict Global Mutation | A technique for forbidding writes to global objects outside one owning module. | https://banes-lab.com/json/records/lexicon/restrict-global-mutation | https://banes-lab.com/records/lexicon/restrict-global-mutation.md | 3046 | 5f125cde903e032ec50d50b7018c4573cbd26a90f129ac5064def6e3ea6f34b6 |
| lexicon:split-abstraction | technique | Split Abstraction | A technique for dividing an abstraction that grew flags for each caller into abstractions that fit one use each. | https://banes-lab.com/json/records/lexicon/split-abstraction | https://banes-lab.com/records/lexicon/split-abstraction.md | 3137 | b0f60491bc9fbee7efccdb7ef2d7c3ceb55e203f9fb3f1552d728da4981199ae |
| lexicon:define-module-boundaries | technique | Define Module Boundaries | A technique for declaring which module owns each piece of code and which entry points other modules may use. | https://banes-lab.com/json/records/lexicon/define-module-boundaries | https://banes-lab.com/records/lexicon/define-module-boundaries.md | 6196 | aa350e450f6201cdfc3f9146652c1e9e9ef6d2a15eeff163bd209b665cec34ec |
| lexicon:broken-inheritance | anti-pattern | Broken Inheritance | A subclass that violates its base type's contract, for example by an override that changes the expected inputs or outputs, so substituting it breaks callers that rely on the base behavior. | https://banes-lab.com/json/records/lexicon/broken-inheritance | https://banes-lab.com/records/lexicon/broken-inheritance.md | 4661 | dd30f757c5fae7ec7d6c6c9c1c570baf21d5e75608718910aceea1c8a367912c |
| lexicon:fat-interface | anti-pattern | Fat Interface | An interface bundling many unrelated operations, forcing clients to depend on methods they never call. | https://banes-lab.com/json/records/lexicon/fat-interface | https://banes-lab.com/records/lexicon/fat-interface.md | 3676 | d0552e8654dc1a5e9598762b1af7d37255eb5171447931cbc6cc6ef7dc9ac85f |
| lexicon:switch-based-extension | anti-pattern | Switch-Based Extension | Extending behavior by editing a growing switch or conditional on a type instead of adding a new polymorphic type. | https://banes-lab.com/json/records/lexicon/switch-based-extension | https://banes-lab.com/records/lexicon/switch-based-extension.md | 3558 | 7dda14f97a486d63dac42efb497c9d4feb7f463daeb13d438c66bdec853b7dbf |
| lexicon:type-switching | anti-pattern | Type Switching | Branching on an object's concrete type instead of dispatching through a shared polymorphic interface or a visitor's double dispatch. | https://banes-lab.com/json/records/lexicon/type-switching | https://banes-lab.com/records/lexicon/type-switching.md | 6113 | be98548e4ab22833f6cac344bb71b060a353740bb4d1a0bd58fc3adf2c0c8f75 |
| lexicon:consumer-specific-contracts | capability | Consumer-Specific Contracts | The ability to give each client an interface exposing only the operations it uses. | https://banes-lab.com/json/records/lexicon/consumer-specific-contracts | https://banes-lab.com/records/lexicon/consumer-specific-contracts.md | 3303 | c5ce0e13b82b4356f17cb5172cf6163fd71db404971b2251612e4ed4cfb96d48 |
| lexicon:feature-extension-without-modification | capability | Feature Extension without Modification | The ability to add new behavior by writing new code rather than editing existing, tested code. | https://banes-lab.com/json/records/lexicon/feature-extension-without-modification | https://banes-lab.com/records/lexicon/feature-extension-without-modification.md | 3289 | 42d4c87375e38a18bbd2c76af7d0c1ecc48039bf2eb3275b65e72fc51c155b54 |
| lexicon:contract-preservation | constraint | Contract Preservation | The requirement that a subtype honor every behavioral guarantee of the type it replaces. | https://banes-lab.com/json/records/lexicon/contract-preservation | https://banes-lab.com/records/lexicon/contract-preservation.md | 3326 | 3a2fa03457fb5f2c4f9f0f8f6876a43ca930b287c72d001339bd3755c156160a |
| lexicon:role-specific-interfaces | constraint | Role-Specific Interfaces | The requirement that interfaces be defined per client role rather than as one general-purpose surface. | https://banes-lab.com/json/records/lexicon/role-specific-interfaces | https://banes-lab.com/records/lexicon/role-specific-interfaces.md | 3272 | 6f67d4dc9fabba19af8d3ef4a7244f8c965106530775f580892cdee516d9e7bf |
| lexicon:interface-proliferation | quality-attribute | Interface Proliferation | The degree to which splitting interfaces finely multiplies the number of small interfaces to manage. | https://banes-lab.com/json/records/lexicon/interface-proliferation | https://banes-lab.com/records/lexicon/interface-proliferation.md | 4237 | d05c421408779be7eaa0a961d116d06f409f75341cb9b22857d5e7f3fc2ee64e |
| lexicon:narrow-specialized-behavior | quality-attribute | Narrow Specialized Behavior | The degree to which honoring a base type's contract constrains a subtype from specializing its own behavior. | https://banes-lab.com/json/records/lexicon/narrow-specialized-behavior | https://banes-lab.com/records/lexicon/narrow-specialized-behavior.md | 4206 | 2b4b4852570885be977b0fd8bf5f0f98c11611ee3185ba164b0ea3b41592addf |
| lexicon:extract-interface | technique | Extract Interface | A technique for declaring the operations clients use as an interface, so the clients depend on it instead of on the class. | https://banes-lab.com/json/records/lexicon/extract-interface | https://banes-lab.com/records/lexicon/extract-interface.md | 10003 | f6e9175c7b8bbaeba0af52c512f1a20a75c0273a0b60b1b62b4c97e2c6382148 |
| lexicon:extract-role-interface | technique | Extract Role Interface | A technique for splitting the operations one client role uses into an interface of their own. | https://banes-lab.com/json/records/lexicon/extract-role-interface | https://banes-lab.com/records/lexicon/extract-role-interface.md | 4179 | 5c77965fd52d23b4e2f42a4d5368ae1d03d7c55e046e2bb8b1a751501f7ef5bd |
| lexicon:split-interface | technique | Split Interface | A technique for dividing a broad interface into smaller ones, each holding operations that change together. | https://banes-lab.com/json/records/lexicon/split-interface | https://banes-lab.com/records/lexicon/split-interface.md | 4111 | c345994cef33c435d5f33e909fde6e2bc78e3824083d374ac734a9b8f6a60b7d |
| lexicon:replace-inheritance-with-delegation | technique | Replace Inheritance with Delegation | A technique for replacing a subclass with a class that holds the former base as a field and forwards to it. | https://banes-lab.com/json/records/lexicon/replace-inheritance-with-delegation | https://banes-lab.com/records/lexicon/replace-inheritance-with-delegation.md | 4121 | 4c3337e4fdaa4de35c1b698d36b3ebb60fa8f92d55c30015bbee4fcdbe120d36 |
| lexicon:split-hierarchy | technique | Split Hierarchy | A technique for dividing a class hierarchy whose subtypes do not honor one contract into hierarchies that each do. | https://banes-lab.com/json/records/lexicon/split-hierarchy | https://banes-lab.com/records/lexicon/split-hierarchy.md | 3275 | c6825c2c2858e33beacfca78dae4644dac592b0e338f32fe90c99cdd0d4b9056 |
| lexicon:invert-dependency | technique | Invert Dependency | A technique for making a high-level module own an abstraction that a low-level module implements. | https://banes-lab.com/json/records/lexicon/invert-dependency | https://banes-lab.com/records/lexicon/invert-dependency.md | 6289 | 363ad549f034a4f0b2191805ea831dbd202bae0c60cde6e295547d489e39aa9b |
| lexicon:crud-only-state-persistence | anti-pattern | CRUD-Only State Persistence | Persisting only current state via create-read-update-delete, discarding the history that event sourcing preserves. | https://banes-lab.com/json/records/lexicon/crud-only-state-persistence | https://banes-lab.com/records/lexicon/crud-only-state-persistence.md | 3694 | 225ef8198b2ba6823fec203a0583f342c39e14bab72be006a501bbead08c26c3 |
| lexicon:direct-event-handler-calls | anti-pattern | Direct Event Handler Calls | Invoking event handlers by direct method call, coupling emitter to handler and defeating the event bus. | https://banes-lab.com/json/records/lexicon/direct-event-handler-calls | https://banes-lab.com/records/lexicon/direct-event-handler-calls.md | 3287 | b4a6601058d10c8dacdfae332ea87fec5569e17a0e9ef427213c2a78de468be5 |
| lexicon:direct-point-to-point-calls | anti-pattern | Direct Point-to-Point Calls | Wiring services together with direct point-to-point calls, coupling each sender to specific receivers. | https://banes-lab.com/json/records/lexicon/direct-point-to-point-calls | https://banes-lab.com/records/lexicon/direct-point-to-point-calls.md | 3762 | f5c2d5055ae344cc9ce2390a03a2d8008839d465caf4fc18ad161e9c8671cc7c |
| lexicon:duplicate-side-effects | anti-pattern | Duplicate Side Effects | Reprocessing a message so its side effects run more than once, corrupting state when not idempotent. | https://banes-lab.com/json/records/lexicon/duplicate-side-effects | https://banes-lab.com/records/lexicon/duplicate-side-effects.md | 4602 | b3b0ca1a12073e3fdde2dfd93c4fbca39069b45208be9b8ed5181c5c986d1027 |
| lexicon:global-acid-transaction | anti-pattern | Global ACID Transaction | Attempting a single ACID transaction spanning multiple distributed services, creating tight coupling and availability loss. | https://banes-lab.com/json/records/lexicon/global-acid-transaction | https://banes-lab.com/records/lexicon/global-acid-transaction.md | 4067 | 02f742afa23abd6e5ce9b7d0a39669960a08992372c18a67091873587df15bb6 |
| lexicon:hidden-temporal-coupling | anti-pattern | Hidden Temporal Coupling | An undocumented ordering requirement between operations that must run in a specific sequence to work correctly. | https://banes-lab.com/json/records/lexicon/hidden-temporal-coupling | https://banes-lab.com/records/lexicon/hidden-temporal-coupling.md | 3347 | 2af89d33d565fb0c0cf4fc2c6203bc579b67c41eaa17324c42ab4a20b5a8df07 |
| lexicon:in-memory-direct-invocation | anti-pattern | In-Memory Direct Invocation | Calling a component directly in-process where a durable queue is needed, losing buffering and delivery guarantees. | https://banes-lab.com/json/records/lexicon/in-memory-direct-invocation | https://banes-lab.com/records/lexicon/in-memory-direct-invocation.md | 3257 | b81a59eab8e923730fef168acbfdacd40c08745154a91431cdc5de08fdc14dd3 |
| lexicon:in-place-mutation | anti-pattern | In-Place Mutation | Overwriting existing records in place where an append-only log is required, destroying history. | https://banes-lab.com/json/records/lexicon/in-place-mutation | https://banes-lab.com/records/lexicon/in-place-mutation.md | 3685 | c7f86946f19d5f73d4bf9b917b377a277225e6490ab8a75d12944ad2d23415ed |
| lexicon:infinite-redelivery-loop | anti-pattern | Infinite Redelivery Loop | Endlessly redelivering a failing message with no dead-letter path, blocking the queue indefinitely. | https://banes-lab.com/json/records/lexicon/infinite-redelivery-loop | https://banes-lab.com/records/lexicon/infinite-redelivery-loop.md | 3722 | da5b4453893cfe714ac48a85e7295ff89bffdb856870c920bc6b6183ae12890c |
| lexicon:infrastructure-events-in-domain | anti-pattern | Infrastructure Events in Domain | Leaking infrastructure or technical events into the domain model, polluting it with concerns it should not hold. | https://banes-lab.com/json/records/lexicon/infrastructure-events-in-domain | https://banes-lab.com/records/lexicon/infrastructure-events-in-domain.md | 3748 | aa84069331c3b329f9b16e7b5b30602ee69b81e18fb695ded0c9cdc225b9e632 |
| lexicon:internal-domain-event-leakage | anti-pattern | Internal Domain Event Leakage | Exposing internal domain events to external consumers, coupling them to private model details. | https://banes-lab.com/json/records/lexicon/internal-domain-event-leakage | https://banes-lab.com/records/lexicon/internal-domain-event-leakage.md | 3787 | df20f60491fd5178ffdc0355e35a3f7b03d05ed9e352d08cd47dca51045329c0 |
| lexicon:irreversible-side-effects | anti-pattern | Irreversible Side Effects | Performing side effects that cannot be undone within a workflow that may need to roll back. | https://banes-lab.com/json/records/lexicon/irreversible-side-effects | https://banes-lab.com/records/lexicon/irreversible-side-effects.md | 3783 | ca1bdeb01865dd18025a865007b02d8e1fa579b3c93dc7391435fd26302468b1 |
| lexicon:mutable-state-only | anti-pattern | Mutable State Only | Keeping only mutable current state with no event record, so past states and changes cannot be recovered. | https://banes-lab.com/json/records/lexicon/mutable-state-only | https://banes-lab.com/records/lexicon/mutable-state-only.md | 3241 | 6fdb6f9e1077940f45fa7794dd95b231ee0636fec595c192b561ee909b918f45 |
| lexicon:point-to-point-coupling | anti-pattern | Point-to-Point Coupling | Coupling a sender directly to a specific receiver, so adding a consumer requires changing the sender. | https://banes-lab.com/json/records/lexicon/point-to-point-coupling | https://banes-lab.com/records/lexicon/point-to-point-coupling.md | 3670 | a8acb8ff64f0dec7396bf174bef1e529e8e2a7baa657ca8cb935c1b9fbab51ea |
| lexicon:shared-database | anti-pattern | Shared Database | Multiple services reading and writing one shared database, coupling them and destroying service autonomy. | https://banes-lab.com/json/records/lexicon/shared-database | https://banes-lab.com/records/lexicon/shared-database.md | 5584 | 0abb04a2117e81dedbff21c2774fcfbdf84887a7b4144ebdbab6fe1dea2bcffd |
| lexicon:single-serial-consumer | anti-pattern | Single Serial Consumer | Processing a queue with one consumer in series, so throughput cannot scale with load. | https://banes-lab.com/json/records/lexicon/single-serial-consumer | https://banes-lab.com/records/lexicon/single-serial-consumer.md | 3645 | a82327a57ed83a35773e578360b8ff76910224d37f7d1d3bdca22ce1ad19226f |
| lexicon:unified-crud-model | anti-pattern | Unified CRUD Model | Using one shared model for both reads and writes, preventing each from being optimized for its purpose. | https://banes-lab.com/json/records/lexicon/unified-crud-model | https://banes-lab.com/records/lexicon/unified-crud-model.md | 3882 | ce667663ccf4b55719fc9c657642a21476503cc905fc1cff47fdff67eb49ed0b |
| lexicon:broker-event-bus | mechanism | Broker/Event Bus | A runtime intermediary that routes messages between publishers and subscribers. | https://banes-lab.com/json/records/lexicon/broker-event-bus | https://banes-lab.com/records/lexicon/broker-event-bus.md | 3699 | 6f166ef9f99e34f5607d72465e78279cceebb9dc434a68fce52112f45e18da7c |
| lexicon:command-query-separation | principle | Command/Query Separation | Separating operations that change state from those that return data, so each method has a single purpose. | https://banes-lab.com/json/records/lexicon/command-query-separation | https://banes-lab.com/records/lexicon/command-query-separation.md | 3284 | f157541bb7cfc075d075e6ba3b05c8953bca37b7dcfe0119f86d6dcb0df58fea |
| lexicon:consumer | mechanism | Consumer | A component that receives and processes messages from a queue or topic. | https://banes-lab.com/json/records/lexicon/consumer | https://banes-lab.com/records/lexicon/consumer.md | 3136 | 7804de5b17d8441a52284db6a65bcc8c1b62ff72ba8e973a278db462a2f9353e |
| lexicon:deduplication-key | artifact | Deduplication Key | A stable identifier attached to a message that lets a consumer detect and drop duplicates. | https://banes-lab.com/json/records/lexicon/deduplication-key | https://banes-lab.com/records/lexicon/deduplication-key.md | 3125 | 88551fb221b15919fba8537610872d537425db41b443fa7d9c6f0f214af27cc2 |
| lexicon:event-contract | constraint | Event Contract | The agreed schema and semantics of an event that publishers and subscribers both honor. | https://banes-lab.com/json/records/lexicon/event-contract | https://banes-lab.com/records/lexicon/event-contract.md | 3097 | 57f3a717e3cc100f1acb1666c8c152d81e76ad722ef4c7c7d51b8a2ab0a5085a |
| lexicon:event-schema | artifact | Event Schema | A formal definition of the structure and fields of an event's payload. | https://banes-lab.com/json/records/lexicon/event-schema | https://banes-lab.com/records/lexicon/event-schema.md | 3543 | 4ffa5d0f753d5fd0c8452912ca0686c42fee7ab2f13abba73cc5e0b0043e3edd |
| lexicon:event-semantics | constraint | Event Semantics | The agreed meaning of what an event represents and the conditions under which it is emitted. | https://banes-lab.com/json/records/lexicon/event-semantics | https://banes-lab.com/records/lexicon/event-semantics.md | 3071 | 04308a4dd179683d0d1e1d07785c3a5d47c5505a0c837d83ee146723bb5c7eb8 |
| lexicon:events | artifact | Events | Records of things that have happened in a system, emitted for other components to react to. | https://banes-lab.com/json/records/lexicon/events | https://banes-lab.com/records/lexicon/events.md | 3585 | ed0cbccf55ecaf76a890d1b6c3577fbe17ef9c4b9fa8b8d382e6f4f0f80512e8 |
| lexicon:immutable-events | constraint | Immutable Events | The requirement that recorded events never change once written, only be appended to. | https://banes-lab.com/json/records/lexicon/immutable-events | https://banes-lab.com/records/lexicon/immutable-events.md | 3102 | bc9e31eef94013b05662191657ef4c4e28d4c504c6a2b7896a553b03c0d4c153 |
| lexicon:local-transaction | model | Local Transaction | A transaction confined to a single service's own datastore, the atomic unit a saga or outbox composes. | https://banes-lab.com/json/records/lexicon/local-transaction | https://banes-lab.com/records/lexicon/local-transaction.md | 3144 | 47e42681e32fd38449b0c6459806849ae5e60b14ff277c4d3c29c3f17a05cdb2 |
| lexicon:message-relay | mechanism | Message Relay | A component that reads pending messages from an outbox and publishes them to the broker. | https://banes-lab.com/json/records/lexicon/message-relay | https://banes-lab.com/records/lexicon/message-relay.md | 3536 | c2bf99a84af3e181756292607ddb6b85dd530da61816e0bad6144c68ece2beb6 |
| lexicon:ordered-log | artifact | Ordered Log | An append-only sequence of records that preserves the order in which they were written. | https://banes-lab.com/json/records/lexicon/ordered-log | https://banes-lab.com/records/lexicon/ordered-log.md | 3058 | c08c85cd3fa2699826b7e7f8f0753dd2935389a22663680bb75ddb8b51711ee2 |
| lexicon:own-data | constraint | Own Data | The requirement that each service alone own and control its data store. | https://banes-lab.com/json/records/lexicon/own-data | https://banes-lab.com/records/lexicon/own-data.md | 2893 | 405abc647b8c4767913cfeee5eed757c21cab7f860cbd76033fb291c8b128789 |
| lexicon:publisher | mechanism | Publisher | A component that emits messages to a topic or bus for subscribers to receive. | https://banes-lab.com/json/records/lexicon/publisher | https://banes-lab.com/records/lexicon/publisher.md | 3564 | 353fe30da40fa9861b9b344fcc99c765a7e6dcb357e9606e0a7d06ad5ba95c95 |
| lexicon:reconciliation | activity | Reconciliation | The activity of detecting and resolving divergence between replicas so they converge to a consistent state. | https://banes-lab.com/json/records/lexicon/reconciliation | https://banes-lab.com/records/lexicon/reconciliation.md | 3205 | 6a4a22a1964ae93f95571a0e49cffa7be3c819ed15a55e611f74a9461991c314 |
| lexicon:reversible-compensable-step | constraint | Reversible/Compensable Step | The requirement that each step in a distributed workflow can be undone by a compensating action. | https://banes-lab.com/json/records/lexicon/reversible-compensable-step | https://banes-lab.com/records/lexicon/reversible-compensable-step.md | 3193 | 4ec5714d360f68a7e3c48b7f52951895be62029f0ecdb1c470f28fd0e2cfccd0 |
| lexicon:routing | capability | Routing | The ability to direct each message to its correct destination based on topic, key, or rule. | https://banes-lab.com/json/records/lexicon/routing | https://banes-lab.com/records/lexicon/routing.md | 3138 | 54cf62f8d22547744cebd9c2ae823e817b0e2f1ad5b00a90c9d8841ec031cf31 |
| lexicon:subscriber | mechanism | Subscriber | A component that registers interest in a topic and receives its messages. | https://banes-lab.com/json/records/lexicon/subscriber | https://banes-lab.com/records/lexicon/subscriber.md | 4027 | 4d068c88defe339f78153c9f93b9fbe2732f97f4e3766b1769dc595fc1e60b10 |
| lexicon:subscriber-model | model | Subscriber Model | A representation of which consumers subscribe to which topics and how they receive messages. | https://banes-lab.com/json/records/lexicon/subscriber-model | https://banes-lab.com/records/lexicon/subscriber-model.md | 3095 | ef9a7faaf3d4ac95f296ef9cc14257355db5857358cb60ffb00877be329d89e1 |
| lexicon:user-expectations | constraint | User Expectations | The behavior users assume a system will exhibit, such as seeing their own writes immediately. | https://banes-lab.com/json/records/lexicon/user-expectations | https://banes-lab.com/records/lexicon/user-expectations.md | 4042 | 69d2e77ee6ba3e723a4b20503f819b0838aaf1c575108e9a398ce944e627ebe8 |
| lexicon:asynchronous-processing | capability | Asynchronous Processing | The ability to handle work without blocking the caller, decoupling request from completion. | https://banes-lab.com/json/records/lexicon/asynchronous-processing | https://banes-lab.com/records/lexicon/asynchronous-processing.md | 3273 | 1aeca4462bd3d330cb227830a6e198b86009a92c03c3287c74e6a05a8407a31d |
| lexicon:atomic-state-change-message-publish | capability | Atomic State Change + Message Publish | The ability to commit a state change and publish its corresponding message as one atomic unit. | https://banes-lab.com/json/records/lexicon/atomic-state-change-message-publish | https://banes-lab.com/records/lexicon/atomic-state-change-message-publish.md | 3279 | 0d9cc26d454fcc520c6e237141f64fb59ebeb9838bac7a14cfc8ba96e95db420 |
| lexicon:consumer-elasticity | capability | Consumer Elasticity | The ability to add or remove consumers dynamically to match message volume. | https://banes-lab.com/json/records/lexicon/consumer-elasticity | https://banes-lab.com/records/lexicon/consumer-elasticity.md | 3779 | 57781c31963048847c5ab578901d71f4b5950b2ddefe3748de6c6249f5a94a54 |
| lexicon:cross-service-communication | capability | Cross-Service Communication | The ability for independent services to exchange information without direct coupling. | https://banes-lab.com/json/records/lexicon/cross-service-communication | https://banes-lab.com/records/lexicon/cross-service-communication.md | 3271 | 57d8e51d309efeac71a548f2b0d6be78c3c71e28a0ec29622989843d3cb73009 |
| lexicon:decoupled-domain-reactions | capability | Decoupled Domain Reactions | The ability for domain logic to react to events without the emitter knowing its consumers. | https://banes-lab.com/json/records/lexicon/decoupled-domain-reactions | https://banes-lab.com/records/lexicon/decoupled-domain-reactions.md | 3297 | 90ef14aa5799b1a03267270de98c0333dc80710b248c3c869234031bf48c1e58 |
| lexicon:decoupled-event-distribution | capability | Decoupled Event Distribution | The ability to distribute events to many consumers without the source depending on any of them. | https://banes-lab.com/json/records/lexicon/decoupled-event-distribution | https://banes-lab.com/records/lexicon/decoupled-event-distribution.md | 3245 | e31dbb0d95a0788df39b9f2f793c8e79132b8a297079e504d6419ccebf857773 |
| lexicon:distributed-autonomy | capability | Distributed Autonomy | The ability for distributed nodes to operate and decide independently without central coordination. | https://banes-lab.com/json/records/lexicon/distributed-autonomy | https://banes-lab.com/records/lexicon/distributed-autonomy.md | 3262 | fb0e31fc9f46659948184dd17ebaf57baa30375803f23945f57b5b493ffbb874 |
| lexicon:failure-recovery | capability | Failure Recovery | The ability to restore correct operation after a failure through compensation or retry. | https://banes-lab.com/json/records/lexicon/failure-recovery | https://banes-lab.com/records/lexicon/failure-recovery.md | 3234 | 179f4c0b047a86d3dd782d41e82633e147ab2c6f050f9f64c3cc36314bee7c6f |
| lexicon:fan-out-notification | capability | Fan-Out Notification | The ability to deliver one event to many interested subscribers at once. | https://banes-lab.com/json/records/lexicon/fan-out-notification | https://banes-lab.com/records/lexicon/fan-out-notification.md | 3245 | 03067246fab6808d96dade03e2f217d27d389c8c704daa0dcee42605256a09b5 |
| lexicon:long-running-transactions | capability | Long-Running Transactions | The ability to carry a business transaction across many steps and a long duration via compensation. | https://banes-lab.com/json/records/lexicon/long-running-transactions | https://banes-lab.com/records/lexicon/long-running-transactions.md | 3257 | 907d67de54740c38cf6b964dd3c6f7e45d2625a74e99caa927e6f6654fda4a95 |
| lexicon:parallel-message-processing | capability | Parallel Message Processing | The ability for multiple consumers to process messages from the same source at once. | https://banes-lab.com/json/records/lexicon/parallel-message-processing | https://banes-lab.com/records/lexicon/parallel-message-processing.md | 3300 | a44fa0366d912f1feb26b7c455c05502e52bb3cfae42d4d831685383cd6530f8 |
| lexicon:poison-message-quarantine | capability | Poison-Message Quarantine | The ability to divert a repeatedly-failing message to a separate queue so it stops blocking others. | https://banes-lab.com/json/records/lexicon/poison-message-quarantine | https://banes-lab.com/records/lexicon/poison-message-quarantine.md | 3327 | 68381c773c02a36e99591dc33e529469632b98015c7edd66dffd83e1b9a26b23 |
| lexicon:read-write-model-optimization | capability | Read/Write Model Optimization | The ability to shape read and write models independently for their differing access patterns. | https://banes-lab.com/json/records/lexicon/read-write-model-optimization | https://banes-lab.com/records/lexicon/read-write-model-optimization.md | 3407 | 078ebe46bb7946d05775b055336533d67504848f3995894f9c6a9bc25c82a5ce |
| lexicon:reprocessing-after-fix | capability | Reprocessing After Fix | The ability to reprocess quarantined messages once the underlying defect is fixed. | https://banes-lab.com/json/records/lexicon/reprocessing-after-fix | https://banes-lab.com/records/lexicon/reprocessing-after-fix.md | 3736 | 170591f00e564f8e3b9427a478dd81425fc28720bf1c1a5dbe401d3bdb3f63b6 |
| lexicon:safe-message-redelivery | capability | Safe Message Redelivery | The ability to redeliver a message without causing duplicate effects, given idempotent handling. | https://banes-lab.com/json/records/lexicon/safe-message-redelivery | https://banes-lab.com/records/lexicon/safe-message-redelivery.md | 3241 | 68037b36275c467a82eaae8796f81a4a7efb491b29022de396e8aa5b96c90e08 |
| lexicon:temporal-modeling | capability | Temporal Modeling | The ability to model how state evolved over time by preserving each change as an event. | https://banes-lab.com/json/records/lexicon/temporal-modeling | https://banes-lab.com/records/lexicon/temporal-modeling.md | 3186 | df6f7de664ac8ff108d0b07fff89766ce454d3baf68c619fbffe1718297c8aac |
| lexicon:temporal-queries | capability | Temporal Queries | The ability to ask what a system's state was at any past point in time. | https://banes-lab.com/json/records/lexicon/temporal-queries | https://banes-lab.com/records/lexicon/temporal-queries.md | 3571 | decd26f4343d4eca2b20e9e305b43e8db924b45fc390476b46acd58303ef6580 |
| lexicon:work-distribution | capability | Work Distribution | The ability to spread units of work across many workers via a broker. | https://banes-lab.com/json/records/lexicon/work-distribution | https://banes-lab.com/records/lexicon/work-distribution.md | 3195 | 787b24102895a08cfd3043714b176e5bab215e814d7d60d6d6612b8df5080727 |
| lexicon:at-least-once-delivery-safety | quality-attribute | At-Least-Once Delivery Safety | The degree to which a message is guaranteed to be delivered at least once, tolerating duplicates. | https://banes-lab.com/json/records/lexicon/at-least-once-delivery-safety | https://banes-lab.com/records/lexicon/at-least-once-delivery-safety.md | 3251 | 94a6757794a122622f09a9770f4837e93749d294eec906e505db5b493951cbdd |
| lexicon:event-reliability | quality-attribute | Event Reliability | The degree to which events are guaranteed to be delivered despite failures. | https://banes-lab.com/json/records/lexicon/event-reliability | https://banes-lab.com/records/lexicon/event-reliability.md | 3226 | ff939a81a02bf02990adecdd15b7c044379b8d10d2dc6c31724586066d215bd8 |
| lexicon:business-complexity | quality-attribute | Business Complexity | The degree of domain intricacy that a coordination mechanism must accommodate. | https://banes-lab.com/json/records/lexicon/business-complexity | https://banes-lab.com/records/lexicon/business-complexity.md | 4067 | 45804893ca203161856cd2988090815ffb1b8624227abb0825b5070a20ba0399 |
| lexicon:delivery-ordering | quality-attribute | Delivery Ordering | The degree to which messages are delivered in a defined order, which broad fan-out can weaken. | https://banes-lab.com/json/records/lexicon/delivery-ordering | https://banes-lab.com/records/lexicon/delivery-ordering.md | 4150 | e2e284fed56560337f64c2448101ecac54d9f802082a1d9cfd84c24ecd06d493 |
| lexicon:duplication-with-domain-events | quality-attribute | Duplication with Domain Events | The degree of overlap between integration events and domain events that must be kept in sync. | https://banes-lab.com/json/records/lexicon/duplication-with-domain-events | https://banes-lab.com/records/lexicon/duplication-with-domain-events.md | 4121 | e457d81d7ae8fa70d2f633e82f308768dca03aa9b2dd687615763bf434c00a04 |
| lexicon:event-granularity | quality-attribute | Event Granularity | The degree of coarseness or fineness at which events are defined, trading detail against volume. | https://banes-lab.com/json/records/lexicon/event-granularity | https://banes-lab.com/records/lexicon/event-granularity.md | 4059 | c1964a20ac9bf0725e3174d2520f60eb18e4ece2b9f843cb37df1f7c3dd378d8 |
| lexicon:event-storm-traceability | quality-attribute | Event Storm / Traceability | The degree to which a high volume of events makes end-to-end flows hard to trace. | https://banes-lab.com/json/records/lexicon/event-storm-traceability | https://banes-lab.com/records/lexicon/event-storm-traceability.md | 3974 | 2dd47562468ed2f0693e156173b52a231d569863775fdff89ea475303284fda7 |
| lexicon:global-consistency | quality-attribute | Global Consistency | The degree to which all nodes reflect the same state at once, which service autonomy gives up. | https://banes-lab.com/json/records/lexicon/global-consistency | https://banes-lab.com/records/lexicon/global-consistency.md | 3857 | 491a9076fe8494b6415e7f5451ac352a045aefdf5c1d53c202755d9055abd4cd |
| lexicon:immediate-consistency | quality-attribute | Immediate Consistency | The degree to which a read reflects the latest write instantly, which asynchronous processing defers. | https://banes-lab.com/json/records/lexicon/immediate-consistency | https://banes-lab.com/records/lexicon/immediate-consistency.md | 4629 | 9a14225bc1ffc68159a811c658eee145f8953d8af9f1b33eda6cee3381587333 |
| lexicon:operational-dependency | quality-attribute | Operational Dependency | The degree to which a system's operation depends on a message broker remaining available. | https://banes-lab.com/json/records/lexicon/operational-dependency | https://banes-lab.com/records/lexicon/operational-dependency.md | 4020 | 16dc2d47fb042c29f3e5144a5d50442ff2b4b24876c395d28b2a70a7334728eb |
| lexicon:query-complexity | quality-attribute | Query Complexity | The degree of difficulty of answering queries when state is stored as an event history rather than current rows. | https://banes-lab.com/json/records/lexicon/query-complexity | https://banes-lab.com/records/lexicon/query-complexity.md | 3994 | 636d3b59930737ddc5de0ea35681c350376668173d8c2d8fbb1fb80e0fbad638 |
| lexicon:relay-complexity | quality-attribute | Relay Complexity | The degree of added complexity of running a relay process that forwards messages from an outbox. | https://banes-lab.com/json/records/lexicon/relay-complexity | https://banes-lab.com/records/lexicon/relay-complexity.md | 3938 | d70fe55c908a33ed567322c81540116ed3b83474f10676797a70a2ac6c929735 |
| lexicon:state-overhead | quality-attribute | State Overhead | The degree of extra state a consumer must retain to deduplicate or order messages. | https://banes-lab.com/json/records/lexicon/state-overhead | https://banes-lab.com/records/lexicon/state-overhead.md | 3956 | 7af1c100a028037321ca77251dd2487f9c4b87bb32a9e8cdb3b65e060d1a4d56 |
| lexicon:storage-growth | quality-attribute | Storage Growth | The degree to which an append-only log's storage footprint grows unbounded over time. | https://banes-lab.com/json/records/lexicon/storage-growth | https://banes-lab.com/records/lexicon/storage-growth.md | 3909 | f855f937eda3645ac72383eca16f45d30c4689b8cffb7a6b160d91b9abf42c4e |
| lexicon:storage-volume | quality-attribute | Storage Volume | The degree to which retaining a full event stream consumes large amounts of storage. | https://banes-lab.com/json/records/lexicon/storage-volume | https://banes-lab.com/records/lexicon/storage-volume.md | 3898 | c305b038fb0490dfe6a801da5a90c7f63bfd6de2c71afb4bfc5e921befa88e74 |
| lexicon:strong-consistency | quality-attribute | Strong Consistency | The degree to which all reads see the latest write, which event-driven asynchrony relaxes. | https://banes-lab.com/json/records/lexicon/strong-consistency | https://banes-lab.com/records/lexicon/strong-consistency.md | 4563 | 90b3b3b379da979618ff86b907069c45c8c54659a798206f670415e8dd17a757 |
| lexicon:strong-immediate-consistency | quality-attribute | Strong Immediate Consistency | The degree to which every read reflects the most recent write without delay, which eventual consistency relaxes. | https://banes-lab.com/json/records/lexicon/strong-immediate-consistency | https://banes-lab.com/records/lexicon/strong-immediate-consistency.md | 4157 | 43c848b742348d386fd59ec3fee5c298c1544adef07af7524fe6c1e9296cac64 |
| lexicon:workflow-complexity | quality-attribute | Workflow Complexity | The degree of intricacy of coordinating a multi-step distributed workflow. | https://banes-lab.com/json/records/lexicon/workflow-complexity | https://banes-lab.com/records/lexicon/workflow-complexity.md | 3993 | 18bd00912277a19743a217bd03d7b4649548d901980b0bd421239e3d995bc39c |
| lexicon:query-projection | technique | Query Projection | A technique for maintaining a read model shaped for one query, updated from the writes it depends on. | https://banes-lab.com/json/records/lexicon/query-projection | https://banes-lab.com/records/lexicon/query-projection.md | 5549 | 770a1ef4951428d42e33f252a21335b5455e94b3cda0fbd69473700c927821e7 |
| lexicon:introduce-async-event | technique | Introduce Async Event | A technique for replacing a synchronous call that need not complete in the request with an event a consumer handles later. | https://banes-lab.com/json/records/lexicon/introduce-async-event | https://banes-lab.com/records/lexicon/introduce-async-event.md | 4320 | 56c4e037c902135a5d634204ed39dc4151d273a22f050ca2af3e3a02f7a5c9b9 |
| lexicon:own-data-per-service | technique | Own Data per Service | A technique for giving each service its own store and letting others reach the data only through its contract. | https://banes-lab.com/json/records/lexicon/own-data-per-service | https://banes-lab.com/records/lexicon/own-data-per-service.md | 4760 | d91ccf806f2f50897606f73702684de540243c1b22a781d19343f63425cbb7c0 |
| lexicon:offset-tracking | technique | Offset Tracking | A technique for recording how far each consumer has read in a stream, so it resumes there and can replay from earlier. | https://banes-lab.com/json/records/lexicon/offset-tracking | https://banes-lab.com/records/lexicon/offset-tracking.md | 3194 | f979683aa02cabaf20dde46bdb726da71e607945241d00015ce4c9fea6eb0092 |
| lexicon:snapshot-compaction | technique | Snapshot Compaction | A technique for periodically storing a snapshot of state derived from a log, so readers replay only the events after it. | https://banes-lab.com/json/records/lexicon/snapshot-compaction | https://banes-lab.com/records/lexicon/snapshot-compaction.md | 3232 | cf52f07faf5b8c31255a85b2be90440245d42186a9a9f2d64bec8c72d37b890e |
| lexicon:non-replayable-processing | anti-pattern | Non-Replayable Processing | A defect in which consumed events cannot be read again, so a consumer cannot rebuild its state or recover from a fault. | https://banes-lab.com/json/records/lexicon/non-replayable-processing | https://banes-lab.com/records/lexicon/non-replayable-processing.md | 3247 | a63c880950f017da605928872e28c40b96242594635bed1dee85c5b6504a9f45 |
| lexicon:all-or-nothing-failure | anti-pattern | All-Or-Nothing Failure | Failing the entire system when one part fails instead of degrading to reduced but working service. | https://banes-lab.com/json/records/lexicon/all-or-nothing-failure | https://banes-lab.com/records/lexicon/all-or-nothing-failure.md | 3678 | efdd77ad3a69c30548244aeffa7da2508dcf46c1a7c3c398c88e5fca650f2b46 |
| lexicon:brittle-architecture | anti-pattern | Brittle Architecture | A fragile design that breaks entirely under any condition it was not explicitly built for. | https://banes-lab.com/json/records/lexicon/brittle-architecture | https://banes-lab.com/records/lexicon/brittle-architecture.md | 3145 | fe1482288514970c43ee9427af79b6ed1824aee22592f6ac8f374e9754183ddd |
| lexicon:exception-swallowing | anti-pattern | Exception Swallowing | Catching an exception and silently discarding it, hiding the failure from callers and logs. | https://banes-lab.com/json/records/lexicon/exception-swallowing | https://banes-lab.com/records/lexicon/exception-swallowing.md | 3853 | ff46391f01354cc986d3d9f3f4c0d8f345bd7ed1d05cb44f87d33bfbc728f431 |
| lexicon:fail-open | anti-pattern | Fail Open | Granting access or continuing when a security check fails, exposing the system on error. | https://banes-lab.com/json/records/lexicon/fail-open | https://banes-lab.com/records/lexicon/fail-open.md | 3496 | 81f0ddfc193c938fa3f28a8f98b8874a029b467efb9878053a45f4476eebb325 |
| lexicon:failure-propagation | anti-pattern | Failure Propagation | Letting a failure spread unchecked across component boundaries instead of containing it. | https://banes-lab.com/json/records/lexicon/failure-propagation | https://banes-lab.com/records/lexicon/failure-propagation.md | 4246 | e3dbe2f57b8fcec04b6c4664496a084efe66386d65fd67ca2719965724cfe7d0 |
| lexicon:fragile-parsing | anti-pattern | Fragile Parsing | Parsing input so rigidly that any minor deviation causes a failure. | https://banes-lab.com/json/records/lexicon/fragile-parsing | https://banes-lab.com/records/lexicon/fragile-parsing.md | 3609 | 4f52ac8b7041627a1e5440138048cf375f6fc875353ba9b6b51da05f1b3d474e |
| lexicon:non-idempotent-operation | anti-pattern | Non-Idempotent Operation | An operation whose repetition changes the result, making it unsafe to retry. | https://banes-lab.com/json/records/lexicon/non-idempotent-operation | https://banes-lab.com/records/lexicon/non-idempotent-operation.md | 5033 | b61a82ab26cd97b453f33794b9456e1ae14175e7afbf3ef71a31c78afad2e939 |
| lexicon:shared-resource-pool | anti-pattern | Shared Resource Pool | Serving all work from one shared resource pool, so one overloaded consumer starves the rest. | https://banes-lab.com/json/records/lexicon/shared-resource-pool | https://banes-lab.com/records/lexicon/shared-resource-pool.md | 3619 | 03f4aa90a23029ac98dd89c24e4984e8be39d6ef794fd8885c45b7bcc1d53308 |
| lexicon:single-behavior-path | anti-pattern | Single Behavior Path | Providing only one execution path with no fallback, so any failure in it fails the whole request. | https://banes-lab.com/json/records/lexicon/single-behavior-path | https://banes-lab.com/records/lexicon/single-behavior-path.md | 3619 | 8aae0fe89dcd22e4efa0f01c0eae849e8d529e41c5b6158773f4ddac3a751b0b |
| lexicon:trusting-invalid-inputs | anti-pattern | Trusting Invalid Inputs | Assuming inputs are valid and using them without checking, so bad data flows through unguarded. | https://banes-lab.com/json/records/lexicon/trusting-invalid-inputs | https://banes-lab.com/records/lexicon/trusting-invalid-inputs.md | 4901 | 445753559b9ba2f205ee711454113f56dbb8d9fae231e3fd48338fb218eb0efa |
| lexicon:unbounded-retry | anti-pattern | Unbounded Retry | Retrying a failing operation endlessly with no limit, amplifying load and delaying recovery. | https://banes-lab.com/json/records/lexicon/unbounded-retry | https://banes-lab.com/records/lexicon/unbounded-retry.md | 3649 | 08aeb2b437bf64f3bb80a4f48b608263754972785c826048a50181fabf20dc24 |
| lexicon:unsafe-default-continuation | anti-pattern | Unsafe Default Continuation | Continuing in an unsafe default state after a failure instead of stopping in a safe one. | https://banes-lab.com/json/records/lexicon/unsafe-default-continuation | https://banes-lab.com/records/lexicon/unsafe-default-continuation.md | 3538 | dbb99c340ad82720dd446603a61a1317cc50b9476f749afa063d91e8e2a2dda6 |
| lexicon:blast-radius-reduction | capability | Blast-Radius Reduction | The ability to contain a failure so it affects only one isolated partition. | https://banes-lab.com/json/records/lexicon/blast-radius-reduction | https://banes-lab.com/records/lexicon/blast-radius-reduction.md | 3166 | 72f1dbfd2fee0db9989d76621bc1688cab332364848979b21c680c0f908c96b2 |
| lexicon:bounded-waiting | capability | Bounded Waiting | The ability to guarantee an operation waits no longer than a set limit. | https://banes-lab.com/json/records/lexicon/bounded-waiting | https://banes-lab.com/records/lexicon/bounded-waiting.md | 3169 | 0a88b848e70fa61a5bff7471e415773d49b2b4513bc494f0c91bc98f05ae33e0 |
| lexicon:cascading-failure-prevention | capability | Cascading Failure Prevention | The ability to stop one component's failure from cascading through its callers. | https://banes-lab.com/json/records/lexicon/cascading-failure-prevention | https://banes-lab.com/records/lexicon/cascading-failure-prevention.md | 3259 | 93a45cf9d68801dc3ef171ad6f611823e6b8cc5080f18069d5e4ddfcded49264 |
| lexicon:continued-operation-under-failure | capability | Continued Operation Under Failure | The ability to keep operating correctly despite the failure of some components. | https://banes-lab.com/json/records/lexicon/continued-operation-under-failure | https://banes-lab.com/records/lexicon/continued-operation-under-failure.md | 3229 | 274ef190817a04a99b7147ba045a0f6e71e77a9da766ec2cbb467a2fea51ac70 |
| lexicon:controlled-failure | capability | Controlled Failure | The ability to fail in a defined, handled way rather than crashing unpredictably. | https://banes-lab.com/json/records/lexicon/controlled-failure | https://banes-lab.com/records/lexicon/controlled-failure.md | 3221 | cd35da68f32d6172d8b3aa4e856125969347b781c87c83eddda4d9bc9e28a11c |
| lexicon:deny-by-default-behavior | capability | Deny-by-Default Behavior | The ability to default to denying access when a security check cannot complete. | https://banes-lab.com/json/records/lexicon/deny-by-default-behavior | https://banes-lab.com/records/lexicon/deny-by-default-behavior.md | 3143 | 255bb7ead466613fa0c1d61ece5b5e8093b9f8b53ca81ea98d82b12c334986b9 |
| lexicon:early-defect-detection | capability | Early Defect Detection | The ability to surface a defect immediately at its source rather than letting it propagate. | https://banes-lab.com/json/records/lexicon/early-defect-detection | https://banes-lab.com/records/lexicon/early-defect-detection.md | 3147 | f7735955a074cb1a700e0d83ae580bed1e937c10126cfbae358f31c78f6255cf |
| lexicon:localized-recovery | capability | Localized Recovery | The ability to recover from a failure within its boundary without restarting the whole system. | https://banes-lab.com/json/records/lexicon/localized-recovery | https://banes-lab.com/records/lexicon/localized-recovery.md | 3164 | 73752d1be35f4c3bfbdd0aff842279e02c12638896b63731d9526d9fa1adac51 |
| lexicon:overload-protection | capability | Overload Protection | The ability to protect a system from being overwhelmed by shedding or slowing incoming load. | https://banes-lab.com/json/records/lexicon/overload-protection | https://banes-lab.com/records/lexicon/overload-protection.md | 3091 | 3e98d28f367c8eee192fdadfd03660b975332a63535503211dff46b27c7f4443 |
| lexicon:safe-failure | capability | Safe Failure | The ability to fail without corrupting state or causing further damage. | https://banes-lab.com/json/records/lexicon/safe-failure | https://banes-lab.com/records/lexicon/safe-failure.md | 3142 | 1c1700dcc0c9520195736afc61230e8deb3a9815dfa7b36b5e56b218a15318e4 |
| lexicon:stability-under-stress | capability | Stability Under Stress | The ability to keep functioning under load spikes and adverse conditions. | https://banes-lab.com/json/records/lexicon/stability-under-stress | https://banes-lab.com/records/lexicon/stability-under-stress.md | 3114 | 12af084cde1bf606acf89921a9650f680efb11a57cca0eb0623c0baf0eee127d |
| lexicon:transient-failure-recovery | capability | Transient Failure Recovery | The ability to recover from short-lived failures by retrying the operation. | https://banes-lab.com/json/records/lexicon/transient-failure-recovery | https://banes-lab.com/records/lexicon/transient-failure-recovery.md | 3102 | f31e889c90e76d2deea16d9100b1463ba06a7088822e91eda4fe47db7fd31472 |
| lexicon:backoff | technique | Backoff | Progressively increasing the wait between retries to avoid overwhelming a recovering dependency. | https://banes-lab.com/json/records/lexicon/backoff | https://banes-lab.com/records/lexicon/backoff.md | 4273 | 38d9e07d24d18ed2ee39c02e5cfb154554af3a374e4a0b7504aad836ca1bde53 |
| lexicon:error-model | model | Error Model | A structured representation of the kinds of errors a system can raise and how they are categorized. | https://banes-lab.com/json/records/lexicon/error-model | https://banes-lab.com/records/lexicon/error-model.md | 3047 | b27250bb6654b19ad61243dc3594ab8bba312ce5447b41fc08b049fc953f4e05 |
| lexicon:alternate-behavior | constraint | Alternate Behavior | The requirement that a defined alternate behavior exist to use when the primary path fails. | https://banes-lab.com/json/records/lexicon/alternate-behavior | https://banes-lab.com/records/lexicon/alternate-behavior.md | 3102 | f7e3e88a80903e10e1778be1982b9ec183e6fcacbab934ac13619ed1d52476f4 |
| lexicon:capacity-signaling | constraint | Capacity Signaling | The requirement that downstream capacity be signaled upstream so producers adjust their rate. | https://banes-lab.com/json/records/lexicon/capacity-signaling | https://banes-lab.com/records/lexicon/capacity-signaling.md | 3114 | ab86499a19dbfb449faa7c999d98667605c07d4de29cf541e2c32e56285a1f37 |
| lexicon:failure-isolation | constraint | Failure Isolation | The requirement that a failure be contained within a boundary so it cannot spread. | https://banes-lab.com/json/records/lexicon/failure-isolation | https://banes-lab.com/records/lexicon/failure-isolation.md | 3119 | 3a6bb888e90810d09ea08159a6f82213ea7b52ae061ef4c69e0dee0af9d21065 |
| lexicon:failure-threshold | constraint | Failure Threshold | The requirement of a defined failure count or rate at which a circuit breaker trips. | https://banes-lab.com/json/records/lexicon/failure-threshold | https://banes-lab.com/records/lexicon/failure-threshold.md | 3151 | 5d1d0a8e31ed060975f5825c9203616236a7b44bf077d8921da18008351902f3 |
| lexicon:feature-isolation | constraint | Feature Isolation | The requirement that individual features be isolated so one can be disabled without taking down others. | https://banes-lab.com/json/records/lexicon/feature-isolation | https://banes-lab.com/records/lexicon/feature-isolation.md | 3160 | c2d07738f49c68c5cc8d7894adcbb0c74c1dead1b3aa8fc24f648d2f0f17475f |
| lexicon:resource-isolation | constraint | Resource Isolation | The requirement that resources be partitioned so exhaustion in one pool cannot starve others. | https://banes-lab.com/json/records/lexicon/resource-isolation | https://banes-lab.com/records/lexicon/resource-isolation.md | 3109 | 3aabdbb375d2e8477d4319153ee39589991ab5f265ac188625c613bf95e1ca8e |
| lexicon:strict-output | constraint | Strict Output | The requirement that a component emit only strictly conformant, well-formed output. | https://banes-lab.com/json/records/lexicon/strict-output | https://banes-lab.com/records/lexicon/strict-output.md | 3074 | 2d392f13502c0d837aa5cb823f9ffd012387dc0327cb5b231de75093e8f73384 |
| lexicon:timeout | constraint | Timeout | The requirement that an operation be given a maximum time to complete before being abandoned. | https://banes-lab.com/json/records/lexicon/timeout | https://banes-lab.com/records/lexicon/timeout.md | 3468 | 2c0ff2279e6a6886c32ca4acb180be06326a51acfa23413b707a7b8127dc2cab |
| lexicon:tolerant-input | constraint | Tolerant Input | The requirement that a component accept and cope with input that deviates from the ideal format. | https://banes-lab.com/json/records/lexicon/tolerant-input | https://banes-lab.com/records/lexicon/tolerant-input.md | 3656 | b34803e12b6290c5b109e8fd4075ac066234091c4d05e057f04a5d8ed26fca10 |
| lexicon:availability-of-degraded-dependency | quality-attribute | Availability of Degraded Dependency | The degree to which tripping a breaker to protect the system also cuts off a still-partly-working dependency. | https://banes-lab.com/json/records/lexicon/availability-of-degraded-dependency | https://banes-lab.com/records/lexicon/availability-of-degraded-dependency.md | 4244 | 046e7ae865977ebd3bbf97086a6818007e9338f0a7fac9941d4958e4e7fb8ed3 |
| lexicon:consistency-feature-completeness | quality-attribute | Consistency / Feature Completeness | The degree to which serving reduced functionality during failure sacrifices full consistency or completeness. | https://banes-lab.com/json/records/lexicon/consistency-feature-completeness | https://banes-lab.com/records/lexicon/consistency-feature-completeness.md | 4199 | bfd94b74569eb7e4ef6c6a6d52e2d36b8b844230c041d0ad597c92c4e1e402ae |
| lexicon:hidden-errors | quality-attribute | Hidden Errors | The degree to which catching failures at a boundary can obscure the underlying errors from view. | https://banes-lab.com/json/records/lexicon/hidden-errors | https://banes-lab.com/records/lexicon/hidden-errors.md | 3983 | f8c4f168fbbe7e849236dd362bc299140b23916dc6c998f05221fdd2f47f2b57 |
| lexicon:load-amplification | quality-attribute | Load Amplification | The degree to which retrying failed operations multiplies load on an already-struggling dependency. | https://banes-lab.com/json/records/lexicon/load-amplification | https://banes-lab.com/records/lexicon/load-amplification.md | 3934 | 9408cabfec18450812f47e844260754b10c2715afd18524a1eb5252bcb6ab611 |
| lexicon:slow-operation-tolerance | quality-attribute | Slow Operation Tolerance | The degree to which enforcing timeouts sacrifices tolerance for legitimately slow operations. | https://banes-lab.com/json/records/lexicon/slow-operation-tolerance | https://banes-lab.com/records/lexicon/slow-operation-tolerance.md | 3952 | 460de4c63d6e343a6eecab67e87019f1db07848629079fd8c6e47e4966c826f8 |
| lexicon:stability | quality-attribute | Stability | The degree to which a system keeps operating steadily without collapsing under load. | https://banes-lab.com/json/records/lexicon/stability | https://banes-lab.com/records/lexicon/stability.md | 3128 | 5a05976c9577fb7711ea4da94eec2ee780f9c547f211b5c697f3008da338ca76 |
| lexicon:stale-reduced-results | quality-attribute | Stale/Reduced Results | The degree to which serving a fallback yields stale or reduced-quality results. | https://banes-lab.com/json/records/lexicon/stale-reduced-results | https://banes-lab.com/records/lexicon/stale-reduced-results.md | 3916 | fa18d7c1518c9eb27264cfe7edcb3e36536dc6dea36a3b6ead4a46b91d715bd6 |
| lexicon:strict-validation | quality-attribute | Strict Validation | The degree to which rejecting deviant input conflicts with accepting it tolerantly. | https://banes-lab.com/json/records/lexicon/strict-validation | https://banes-lab.com/records/lexicon/strict-validation.md | 3944 | 0e2c40d1540b95a13b5980cffa3a13ef857c1dba568ec346285e72600eb0b114 |
| lexicon:verbosity | quality-attribute | Verbosity | The degree to which pervasive defensive checks add verbosity and clutter to the code. | https://banes-lab.com/json/records/lexicon/verbosity | https://banes-lab.com/records/lexicon/verbosity.md | 3929 | 89b6f4c1c31781c1882fac3c471527ac32d96126a66d4e23bb3ec6bd11d3fc47 |
| lexicon:introduce-typed-result | technique | Introduce Typed Result | A technique for returning success or a typed error as a value, so callers handle failure through the type system. | https://banes-lab.com/json/records/lexicon/introduce-typed-result | https://banes-lab.com/records/lexicon/introduce-typed-result.md | 6072 | 6080a55985aef70435014fbc1d7184d4349f8b865a89c004b798728fbf36126f |
| lexicon:translate-errors-at-the-boundary | technique | Translate Errors at the Boundary | A technique for converting vendor and infrastructure errors into the core's own error types where they enter. | https://banes-lab.com/json/records/lexicon/translate-errors-at-the-boundary | https://banes-lab.com/records/lexicon/translate-errors-at-the-boundary.md | 3181 | ce75c3a717f01660c14bbb0255cc3287334b91164d37514880cb062a4bcf4423 |
| lexicon:idempotency-key | technique | Idempotency Key | A technique for tagging each request with a unique key, so a repeated request is recognized and applied once. | https://banes-lab.com/json/records/lexicon/idempotency-key | https://banes-lab.com/records/lexicon/idempotency-key.md | 4795 | 1bc26189e777a852387cb9239679be84307a7c3ceb3465d8ea16c1e445928cc3 |
| lexicon:bounded-retry | technique | Bounded Retry | A technique for retrying a failed call a limited number of times with growing delays before giving up. | https://banes-lab.com/json/records/lexicon/bounded-retry | https://banes-lab.com/records/lexicon/bounded-retry.md | 3813 | 564cd1772ba8033dabc0f6f9381f3e852f1ee7599c99e339122f8baaa7694f61 |
| lexicon:jitter | technique | Jitter | A technique for adding a random offset to retry delays, so clients that failed together do not retry together. | https://banes-lab.com/json/records/lexicon/jitter | https://banes-lab.com/records/lexicon/jitter.md | 3003 | b2084e4a9d0024bdda1d739cab3566435d4d31b014379c7be93539606bc5095f |
| lexicon:deadline-propagation | technique | Deadline Propagation | A technique for passing the time left for a request to every call it makes, so downstream work stops when the caller has given up. | https://banes-lab.com/json/records/lexicon/deadline-propagation | https://banes-lab.com/records/lexicon/deadline-propagation.md | 3879 | dfc75ece25ba4a79a73bf64d6feb196e48fa1c246631943a411bbf6a5c9cea0b |
| lexicon:cancellation | technique | Cancellation | A technique for letting a caller stop work it no longer needs, releasing the resources that work holds. | https://banes-lab.com/json/records/lexicon/cancellation | https://banes-lab.com/records/lexicon/cancellation.md | 3045 | 5c2ed09c833106d742e24d76c39c90d7f56289d1a11ed7821fab176d7bfdd000 |
| lexicon:load-shedding | technique | Load Shedding | A technique for refusing part of the incoming work when load passes capacity, so the work already accepted completes. | https://banes-lab.com/json/records/lexicon/load-shedding | https://banes-lab.com/records/lexicon/load-shedding.md | 3043 | ce18556b4ffbe309ec9890dcc560b106bf6800c166077df1eb9a5358bf0b11f0 |
| lexicon:bounded-queue | technique | Bounded Queue | A technique for giving a queue a fixed capacity, so producers are slowed or refused instead of exhausting memory. | https://banes-lab.com/json/records/lexicon/bounded-queue | https://banes-lab.com/records/lexicon/bounded-queue.md | 3924 | 3e8b2324e189f8d120357104f370d17f6c6dfa304e09989d94659b4540a01083 |
| lexicon:fail-fast-or-fall-back | technique | Fail Fast or Fall Back | A technique for deciding per failure whether to stop with an error at once or to continue on a declared fallback. | https://banes-lab.com/json/records/lexicon/fail-fast-or-fall-back | https://banes-lab.com/records/lexicon/fail-fast-or-fall-back.md | 4590 | f5513e88d10227c5fdfe7999f3a0f7bdbd9c089b33dce9079e13fbb3cbeacb76 |
| lexicon:ad-hoc-design | anti-pattern | Ad-Hoc Design | Designing by improvisation with no deliberate structure or review, so the architecture accretes inconsistently. | https://banes-lab.com/json/records/lexicon/ad-hoc-design | https://banes-lab.com/records/lexicon/ad-hoc-design.md | 3795 | 1413b99356c273fcade43ba96eb0e057846d590216324f93fb49956fec883140 |
| lexicon:ad-hoc-pattern-mixing | anti-pattern | Ad-Hoc Pattern Mixing | Combining unrelated design patterns arbitrarily with no coherent rationale, producing an inconsistent structure. | https://banes-lab.com/json/records/lexicon/ad-hoc-pattern-mixing | https://banes-lab.com/records/lexicon/ad-hoc-pattern-mixing.md | 3823 | 92dd57ca9f50e6466f25126b98714845f59d9b0e0b56d10fc7d986e05495c7b8 |
| lexicon:analysis-overhead | quality-attribute | Analysis Overhead | The degree to which analyzing the impact of every change before making it adds effort and slows delivery. | https://banes-lab.com/json/records/lexicon/analysis-overhead | https://banes-lab.com/records/lexicon/analysis-overhead.md | 4196 | 8cbec1e652053018f9693402366163911263c6ec596c0be173ca64931fc35dda |
| lexicon:architecture-criteria | constraint | Architecture Criteria | The requirement that explicit criteria define what a review judges an architecture against. | https://banes-lab.com/json/records/lexicon/architecture-criteria | https://banes-lab.com/records/lexicon/architecture-criteria.md | 3379 | 0339db73b45dd3210f2eeafa53f34aff14335dde7f90248323c5da2c454eefb1 |
| lexicon:architecture-drift | anti-pattern | Architecture Drift | Gradual divergence of an implementation from its intended architecture as unreviewed changes accumulate. | https://banes-lab.com/json/records/lexicon/architecture-drift | https://banes-lab.com/records/lexicon/architecture-drift.md | 4343 | b3cf70169216a91e757dd6833115bef8f96c9521211ce4f69de6b79a79dbb7be |
| lexicon:architecture-foundation | quality-attribute | Architecture Foundation | The degree to which a system rests on a sound, deliberately designed architectural base rather than accreted structure. | https://banes-lab.com/json/records/lexicon/architecture-foundation | https://banes-lab.com/records/lexicon/architecture-foundation.md | 3444 | 7c022bc9b8353c035071c8bcff0cd80ef962c476039ae4ad763df1638f0a6060 |
| lexicon:architecture-rules | constraint | Architecture Rules | The requirement that explicit, checkable rules govern how the architecture may be structured and evolved. | https://banes-lab.com/json/records/lexicon/architecture-rules | https://banes-lab.com/records/lexicon/architecture-rules.md | 3476 | adbbb9e623f797c756568c2af55412daa641a5ad48c2bdb70e020d1e5bf3277c |
| lexicon:assumption-based-judgment | anti-pattern | Assumption-Based Judgment | Judging an architecture from untested assumptions instead of measured evidence, yielding unreliable conclusions. | https://banes-lab.com/json/records/lexicon/assumption-based-judgment | https://banes-lab.com/records/lexicon/assumption-based-judgment.md | 3784 | 16ca929c1c2f110f5a176317d2370777a04d692f2056911c0650c53b6a61aeb7 |
| lexicon:attribute-scenarios | artifact | Attribute Scenarios | A concrete scenario specifying how a quality attribute should hold under defined conditions and stimuli. | https://banes-lab.com/json/records/lexicon/attribute-scenarios | https://banes-lab.com/records/lexicon/attribute-scenarios.md | 3492 | a3f0211614b2c9fd0efee7b4a8f6c67e801d6c846df3317ad607153f0e830e16 |
| lexicon:automated-architecture-compliance | capability | Automated Architecture Compliance | The ability to verify conformance to architectural rules automatically rather than by manual review. | https://banes-lab.com/json/records/lexicon/automated-architecture-compliance | https://banes-lab.com/records/lexicon/automated-architecture-compliance.md | 3405 | 9b16b256f4eb5e0a408d612f16ac561b5ce3f513bcf0f2b55306f884392ef58a |
| lexicon:blind-change | anti-pattern | Blind Change | Changing a system without analyzing what the change affects, so unintended consequences go unseen. | https://banes-lab.com/json/records/lexicon/blind-change | https://banes-lab.com/records/lexicon/blind-change.md | 3813 | fb1a6e7ddaa5c8d48554d14c191782e26be492b7f3754a5f216801e54851a5ab |
| lexicon:change-safety | quality-attribute | Change Safety | The degree to which a change can be made with confidence that its effects are understood and contained. | https://banes-lab.com/json/records/lexicon/change-safety | https://banes-lab.com/records/lexicon/change-safety.md | 3338 | 3d0b95a614102926146369a0449a36a4757347a7190c8bcf49d92f4c880c5f0d |
| lexicon:clean-boundary-design | capability | Clean Boundary Design | The ability to define clear component boundaries from the outset, free of legacy entanglement. | https://banes-lab.com/json/records/lexicon/clean-boundary-design | https://banes-lab.com/records/lexicon/clean-boundary-design.md | 3386 | 0abab514e3fca5bea864f584fa83baae9169454bb6face0be0df1f19f4fa3123 |
| lexicon:competing-attributes | quality-attribute | Competing Attributes | The degree to which improving one quality attribute forces a trade-off against another. | https://banes-lab.com/json/records/lexicon/competing-attributes | https://banes-lab.com/records/lexicon/competing-attributes.md | 4190 | 51b078b1249f4f08cdf9aa6ac7bc78b2ef0d110a7e0060c7e4b040402737f1b0 |
| lexicon:consequences | artifact | Consequences | A recorded account of the trade-offs and downstream effects that follow from an architectural decision. | https://banes-lab.com/json/records/lexicon/consequences | https://banes-lab.com/records/lexicon/consequences.md | 4419 | cd0a1dc06e3a67d3e88ab681cb9be50c986a0cb93ca0787a5a36b9d804042046 |
| lexicon:continuous-improvement | activity | Continuous Improvement | Iteratively refining a system's design in small, ongoing steps rather than in large infrequent overhauls. | https://banes-lab.com/json/records/lexicon/continuous-improvement | https://banes-lab.com/records/lexicon/continuous-improvement.md | 3477 | d08776ec4662b8f2dd404c7053a52af67aeab93c1513cf18f1c2dd8f4352403b |
| lexicon:controlled-architecture-evolution | capability | Controlled Architecture Evolution | The ability to let an architecture change over time within deliberate guardrails rather than drifting freely. | https://banes-lab.com/json/records/lexicon/controlled-architecture-evolution | https://banes-lab.com/records/lexicon/controlled-architecture-evolution.md | 3449 | 3154c0c6be44f0283c73eb65ae05e292c977c5e4b3005e29f3dd1b6e59a3fbeb |
| lexicon:criteria | constraint | Criteria | The requirement that explicit, agreed measures define how an assessment reaches its verdict. | https://banes-lab.com/json/records/lexicon/criteria | https://banes-lab.com/records/lexicon/criteria.md | 3338 | 35deb08d7550dbe0035dd53172f12b1eae2109539959adf8ad33c475539582b5 |
| lexicon:current-state | model | Current State | A conceptual representation of how a system is presently structured and behaves, used as the baseline for analysis. | https://banes-lab.com/json/records/lexicon/current-state | https://banes-lab.com/records/lexicon/current-state.md | 3789 | 19861b26e90f02e06e02c1b4636558bff78e4ecb2d878550d1bf0d003f06810b |
| lexicon:decision | artifact | Decision | A recorded architectural choice capturing what was chosen and the context in which it was made. | https://banes-lab.com/json/records/lexicon/decision | https://banes-lab.com/records/lexicon/decision.md | 3777 | 82e2e4179b30d598c13eb7f6aa9aabb56b735a77647445ba56b2e4dc94016701 |
| lexicon:decision-history | capability | Decision History | The ability to trace why past architectural choices were made by consulting their recorded rationale. | https://banes-lab.com/json/records/lexicon/decision-history | https://banes-lab.com/records/lexicon/decision-history.md | 3363 | 61fe4e29d1e533d877c4ddc1b8d3e1ef8a625e43b06a06245d8655462cb17fa6 |
| lexicon:defect-detection | capability | Defect Detection | The ability to find defects in a change before it is merged or shipped. | https://banes-lab.com/json/records/lexicon/defect-detection | https://banes-lab.com/records/lexicon/defect-detection.md | 3278 | dfb7c76e8ae48096588caae7cb975f3fef4432d00d6974f6aa60cd7a1374a842 |
| lexicon:design-criteria | constraint | Design Criteria | The requirement that explicit criteria define what a design review evaluates a proposal against. | https://banes-lab.com/json/records/lexicon/design-criteria | https://banes-lab.com/records/lexicon/design-criteria.md | 3395 | 5181ac7e1783fb04aa94d5abd6f0b8318a035b62a8aa9dc6468bd389208bf89f |
| lexicon:direct-to-main-unreviewed-change | anti-pattern | Direct-to-main Unreviewed Change | Pushing changes straight to the main branch with no review, so unvetted code lands directly in production. | https://banes-lab.com/json/records/lexicon/direct-to-main-unreviewed-change | https://banes-lab.com/records/lexicon/direct-to-main-unreviewed-change.md | 3831 | 9a54f8645c4a61d895a58d94d688b39f989b77d5f5d2a86cf92a39c5247acae3 |
| lexicon:documentation-maintenance | quality-attribute | Documentation Maintenance | The degree to which keeping decision records current adds ongoing upkeep effort. | https://banes-lab.com/json/records/lexicon/documentation-maintenance | https://banes-lab.com/records/lexicon/documentation-maintenance.md | 4470 | 2f42ce42ecc8ecfc073f98655c04bde64e35184052d00acd6d409620b5488f08 |
| lexicon:early-defect-prevention | capability | Early Defect Prevention | The ability to catch design flaws during review before they are built into the system. | https://banes-lab.com/json/records/lexicon/early-defect-prevention | https://banes-lab.com/records/lexicon/early-defect-prevention.md | 3451 | bd05bd46bc8cf2033beb62b1f421b45b9bd2cccb2b6dcdf26f1fca21308b93b4 |
| lexicon:early-delivery-with-guardrails | capability | Early Delivery with Guardrails | The ability to ship a minimal architecture quickly while keeping essential safeguards in place. | https://banes-lab.com/json/records/lexicon/early-delivery-with-guardrails | https://banes-lab.com/records/lexicon/early-delivery-with-guardrails.md | 3488 | aa72720355b488959ea2e563d37fdde7f55b3324041c58fec1d2103c695564b7 |
| lexicon:easier-refactoring | capability | Easier Refactoring | The ability to restructure code more safely because consistent patterns make change predictable. | https://banes-lab.com/json/records/lexicon/easier-refactoring | https://banes-lab.com/records/lexicon/easier-refactoring.md | 3486 | 4091a858cd3d0e20c997ddab6a5340ed44178233b7306804c7535bfb4ab8bcb6 |
| lexicon:essential-quality-attributes | constraint | Essential Quality Attributes | The requirement that the few quality attributes critical to viability be satisfied before any others. | https://banes-lab.com/json/records/lexicon/essential-quality-attributes | https://banes-lab.com/records/lexicon/essential-quality-attributes.md | 3512 | 41bf4ddc7bcdf19e6f2cfb78e4f08cc955d5e3de020c2c98a8b7b462801e4b94 |
| lexicon:fit-for-purpose-architecture | capability | Fit-for-Purpose Architecture | The ability to shape an architecture to the problem it solves rather than to convention. | https://banes-lab.com/json/records/lexicon/fit-for-purpose-architecture | https://banes-lab.com/records/lexicon/fit-for-purpose-architecture.md | 3478 | 995380a66dea2701d12e311a6c2ef3cdceff177731a45fcff14ac39b3a28dba3 |
| lexicon:future-scalability | quality-attribute | Future Scalability | The degree to which a design can grow to meet higher future demand without rework. | https://banes-lab.com/json/records/lexicon/future-scalability | https://banes-lab.com/records/lexicon/future-scalability.md | 4337 | 41a218295a606000dc5f29541d9729dfdaa1ce259f7725faec65ab39317e2900 |
| lexicon:governance-discipline | quality-attribute | Governance Discipline | The degree to which evolving an architecture continuously demands sustained governance to prevent uncontrolled drift. | https://banes-lab.com/json/records/lexicon/governance-discipline | https://banes-lab.com/records/lexicon/governance-discipline.md | 4319 | f35d758877f054c4980816c3a5232c9bb85d0d665b5e6d70a41a430b44bca729 |
| lexicon:innovation-autonomy | quality-attribute | Innovation/Autonomy | The degree to which enforcing standards constrains teams' freedom to innovate independently. | https://banes-lab.com/json/records/lexicon/innovation-autonomy | https://banes-lab.com/records/lexicon/innovation-autonomy.md | 4186 | 9b55750eb5b3d0c98e9317ffc0fca3fad7258d13973dea094266b769361ec389 |
| lexicon:legacy-constraints | constraint | Legacy Constraints | A binding limitation imposed by pre-existing legacy systems that a new design must accommodate. | https://banes-lab.com/json/records/lexicon/legacy-constraints | https://banes-lab.com/records/lexicon/legacy-constraints.md | 4213 | b44715a106a169e2202394fc7bdba9d77028a38f763f025372952ec6260f311d |
| lexicon:local-autonomy | quality-attribute | Local Autonomy | The degree to which enforcing architectural consistency limits individual teams' freedom to make local choices. | https://banes-lab.com/json/records/lexicon/local-autonomy | https://banes-lab.com/records/lexicon/local-autonomy.md | 4245 | 2b8cbcd14325a42e2256207accb04cb275517f98c4d7d3fe047521c5b2a603f5 |
| lexicon:local-optimization | quality-attribute | Local Optimization | The degree to which enforcing shared patterns sacrifices locally optimal one-off solutions. | https://banes-lab.com/json/records/lexicon/local-optimization | https://banes-lab.com/records/lexicon/local-optimization.md | 4246 | 86efbd9f490bd0cf436604443e13b65f05c492ece775a99f272b562973764972 |
| lexicon:manual-architecture-review-only | anti-pattern | Manual Architecture Review Only | Relying solely on human review to police architecture, with no automated checks, so violations slip through. | https://banes-lab.com/json/records/lexicon/manual-architecture-review-only | https://banes-lab.com/records/lexicon/manual-architecture-review-only.md | 3482 | f12047292988058feb41341af47112bb93d39496650f114093af99e3d4accc48 |
| lexicon:measurable-architecture-rule | constraint | Measurable Architecture Rule | The requirement that an architectural rule be expressed as an objective, automatically checkable measure. | https://banes-lab.com/json/records/lexicon/measurable-architecture-rule | https://banes-lab.com/records/lexicon/measurable-architecture-rule.md | 3531 | 36de017c64c7ce58f800ced9d5f28a88c724dd3eedc05a8e4fad58d6d54be03e |
| lexicon:naming-structure-conventions | style | Naming/Structure Conventions | A convention of naming and structuring code uniformly across a codebase so its shape is predictable. | https://banes-lab.com/json/records/lexicon/naming-structure-conventions | https://banes-lab.com/records/lexicon/naming-structure-conventions.md | 3431 | d6b9850e7391fcaa339653ea3dc56f77d83c993a1617cd1a53dc8162f6af1d8b |
| lexicon:operability | quality-attribute | Operability | The degree to which a system is easy to run, monitor, and keep healthy in production. | https://banes-lab.com/json/records/lexicon/operability | https://banes-lab.com/records/lexicon/operability.md | 3389 | 4b7a1e13ac397e5b160a13f26127c6856c7580f2f24b493c1f70202bf52b769a |
| lexicon:predictable-evolution | capability | Predictable Evolution | The ability to change a system with confidence that consistent structure keeps outcomes foreseeable. | https://banes-lab.com/json/records/lexicon/predictable-evolution | https://banes-lab.com/records/lexicon/predictable-evolution.md | 3412 | 6909141641bee0a7ebe1264d8c6f88ae1f7f186f3c500eae6cb28e541ef338d2 |
| lexicon:prioritized-refactoring | capability | Prioritized Refactoring | The ability to rank refactoring work by assessed impact so effort targets the highest-value fixes. | https://banes-lab.com/json/records/lexicon/prioritized-refactoring | https://banes-lab.com/records/lexicon/prioritized-refactoring.md | 3383 | 2fb48fa8f6e21fad3aad55df8fd2a60c3f8be68a1df52551b6fc4809b2f6d57f |
| lexicon:problem-decomposition | activity | Problem Decomposition | Breaking a problem into fundamental sub-problems that can be reasoned about independently. | https://banes-lab.com/json/records/lexicon/problem-decomposition | https://banes-lab.com/records/lexicon/problem-decomposition.md | 3371 | d1137212980462d924de8714451f4aee1b5f515ad32a60c17f428e6f5e762053 |
| lexicon:quality | quality-attribute | Quality | The degree to which a system meets its functional and non-functional expectations. | https://banes-lab.com/json/records/lexicon/quality | https://banes-lab.com/records/lexicon/quality.md | 4238 | 4c2a62d83d16d07cf95d7efc03852337a8cadf4582a68ee2fc6ef86ac265dcd6 |
| lexicon:quality-goals | constraint | Quality Goals | The requirement that target levels for key quality attributes be defined for an architecture to meet. | https://banes-lab.com/json/records/lexicon/quality-goals | https://banes-lab.com/records/lexicon/quality-goals.md | 3362 | 48e3de54aafe69b90ba5ff42920a164503cb9532f4a84da5371739c1e63fe354 |
| lexicon:regression-scope-selection | capability | Regression Scope Selection | The ability to select exactly which tests a change requires by analyzing what it affects. | https://banes-lab.com/json/records/lexicon/regression-scope-selection | https://banes-lab.com/records/lexicon/regression-scope-selection.md | 3366 | 02a7d942b323e20c89a93d82608f3d37abe382e53c387585f4c43b1c6d2c07d8 |
| lexicon:remediation-planning | capability | Remediation Planning | The ability to plan the steps that close the gap between a system's current and target states. | https://banes-lab.com/json/records/lexicon/remediation-planning | https://banes-lab.com/records/lexicon/remediation-planning.md | 3447 | 92d06458ce00332dce282e71be5cb79637100dde06a5d99034764b0561d1e062 |
| lexicon:reusable-architecture-guidance | artifact | Reusable Architecture Guidance | A body of proven architectural guidance packaged for reuse across projects. | https://banes-lab.com/json/records/lexicon/reusable-architecture-guidance | https://banes-lab.com/records/lexicon/reusable-architecture-guidance.md | 3481 | 82697e77b57b4e547e83d3bde06363645c6ec91e9082ca47dca676afbe094ca6 |
| lexicon:reuse-of-established-patterns | quality-attribute | Reuse of Established Patterns | The degree to which designing from first principles forgoes the leverage of reusing proven patterns. | https://banes-lab.com/json/records/lexicon/reuse-of-established-patterns | https://banes-lab.com/records/lexicon/reuse-of-established-patterns.md | 4399 | b6f8db7474228b2aa6fb90cf857c7e31f18446b566abedb5c00a2b483e8b372b |
| lexicon:review-standards | constraint | Review Standards | The requirement that agreed standards define what a code review checks for. | https://banes-lab.com/json/records/lexicon/review-standards | https://banes-lab.com/records/lexicon/review-standards.md | 3343 | 6cd03db70bf96daaa6cccf4e1bbaf5944c7ed6ffbd4ffa8a7c2d880756ffa58b |
| lexicon:risk-detection | capability | Risk Detection | The ability to surface architectural risks early by reviewing structure before it is built. | https://banes-lab.com/json/records/lexicon/risk-detection | https://banes-lab.com/records/lexicon/risk-detection.md | 3340 | 068916848a0a0b451ff8dc365ee6cbbf3c1f44b05e7a57f8e5237962211f942d |
| lexicon:standard-patterns | pattern | Standard Patterns | A canonical, widely agreed reusable solution that a reference architecture prescribes for a recurring problem. | https://banes-lab.com/json/records/lexicon/standard-patterns | https://banes-lab.com/records/lexicon/standard-patterns.md | 3389 | 184cd509f3ae45527046084ac208d4045d092fdbcf44c92677078bc766e894dc |
| lexicon:standards-definition | artifact | Standards Definition | A defined, authoritative set of standards that units are expected to conform to. | https://banes-lab.com/json/records/lexicon/standards-definition | https://banes-lab.com/records/lexicon/standards-definition.md | 3312 | 79a3884c002cb0411a86e1e66878f8f5ec4d52d5860fec687f6d6f36801139cb |
| lexicon:target-state | model | Target State | A conceptual representation of the desired future structure a system is being steered toward. | https://banes-lab.com/json/records/lexicon/target-state | https://banes-lab.com/records/lexicon/target-state.md | 3320 | ce8f21295487a097f444f8ff9762a3ea1dc6559b51d0314f3c69960fe6e6c0c1 |
| lexicon:trade-off-analysis | capability | Trade-Off Analysis | The ability to weigh competing quality attributes and choose a balanced compromise between them. | https://banes-lab.com/json/records/lexicon/trade-off-analysis | https://banes-lab.com/records/lexicon/trade-off-analysis.md | 3331 | e0801a9816c92af1be9b0c35bfc12a96bde229cce608476c683411b21de837b4 |
| lexicon:tribal-knowledge | anti-pattern | Tribal Knowledge | Critical architectural knowledge held only in the developers' heads and never recorded, lost when they leave. | https://banes-lab.com/json/records/lexicon/tribal-knowledge | https://banes-lab.com/records/lexicon/tribal-knowledge.md | 3960 | c9b553586a459e35cafa173280933495706c1be8dd939f429e411cdc6244ce60 |
| lexicon:uncoordinated-divergence | anti-pattern | Uncoordinated Divergence | Teams independently diverging from a shared reference architecture, fragmenting the system into incompatible variants. | https://banes-lab.com/json/records/lexicon/uncoordinated-divergence | https://banes-lab.com/records/lexicon/uncoordinated-divergence.md | 3896 | dd5730d485368553cfcf3e1b7994fc8eafcdd609e313d2927923de7d14e152da |
| lexicon:unbounded-variation | anti-pattern | Unbounded Variation | Allowing unlimited variation in how the same problem is solved, so the system sprawls into inconsistent one-offs. | https://banes-lab.com/json/records/lexicon/unbounded-variation | https://banes-lab.com/records/lexicon/unbounded-variation.md | 3419 | d5fcc412dda7e1cdd8f4a0ad117b6bb59fc64c3c85922ddf6384d5903dfa15b1 |
| lexicon:unknown-requirements | quality-attribute | Unknown Requirements | The degree to which starting on a clean slate forces early decisions while requirements are still unknown. | https://banes-lab.com/json/records/lexicon/unknown-requirements | https://banes-lab.com/records/lexicon/unknown-requirements.md | 4319 | 50ccd8cb6a0abae48053d167a30e50bed7a1f16be69d2a780e57e67756e71434 |
| lexicon:unreviewed-structural-change | anti-pattern | Unreviewed Structural Change | Merging changes to architectural structure without review, letting unvetted design decisions into the system. | https://banes-lab.com/json/records/lexicon/unreviewed-structural-change | https://banes-lab.com/records/lexicon/unreviewed-structural-change.md | 3888 | 1f0b73f4c08e18ebc0d80d3a0c7a16d23cce64a666b39a53dc660b06ea1214bf |
| lexicon:incremental-change | constraint | Incremental Change | The requirement that a system evolve in small, reversible increments rather than large risky leaps. | https://banes-lab.com/json/records/lexicon/incremental-change | https://banes-lab.com/records/lexicon/incremental-change.md | 3450 | db4279382c537dd6210a13a3e4d31e30cbad22d566c07d593fb2fbf741dc7259 |
| lexicon:rule-maintenance | quality-attribute | Rule Maintenance | The degree to which keeping fitness-function rules current adds ongoing upkeep effort. | https://banes-lab.com/json/records/lexicon/rule-maintenance | https://banes-lab.com/records/lexicon/rule-maintenance.md | 4148 | 960da8cf6d80d566c7a8a8353241240c746f19d7b832bc276eaafc63e080e691 |
| lexicon:undefined-target | anti-pattern | Undefined Target | Attempting to close a gap toward a goal that was never clearly defined, so progress cannot be judged. | https://banes-lab.com/json/records/lexicon/undefined-target | https://banes-lab.com/records/lexicon/undefined-target.md | 3757 | 9899479970eddb183b321a4294602dc4efd4d5f867c7e1d34f9fb1564aa5c50f |
| lexicon:delete-after-evidence | technique | Delete After Evidence | A technique for removing code once measurement shows nothing calls it. | https://banes-lab.com/json/records/lexicon/delete-after-evidence | https://banes-lab.com/records/lexicon/delete-after-evidence.md | 3441 | f9e1c626022afd07913bc43b5b8466859069b914c0b9f63f6ac6f861c1dc2aac |
| lexicon:deprecation-plan | technique | Deprecation Plan | A technique for recording for each obsolete path its owner, its replacement and its removal date. | https://banes-lab.com/json/records/lexicon/deprecation-plan | https://banes-lab.com/records/lexicon/deprecation-plan.md | 3113 | 77ab6aa1efc5f73bf01b7b6c9c733deed824ae50a2343aaf8a329ec8a71e81fd |
| lexicon:assign-owner | technique | Assign Owner | A technique for recording a named owner for each module, risk or rule, who decides on its changes. | https://banes-lab.com/json/records/lexicon/assign-owner | https://banes-lab.com/records/lexicon/assign-owner.md | 5125 | 8c4912213243f399bee7257b059ffa880fbf665e5d40f7bfe97a132a26881e0b |
| lexicon:severity-classification | technique | Severity Classification | A technique for ranking each finding or risk on a declared scale that sets how soon it is handled. | https://banes-lab.com/json/records/lexicon/severity-classification | https://banes-lab.com/records/lexicon/severity-classification.md | 3127 | 1875605568a0497cef7cc77763d5f9dadbde9b8a2ed230f8354e4e4ca9dbf203 |
| lexicon:mitigation-plan | technique | Mitigation Plan | A technique for recording the actions that reduce a risk, with an owner and a date for each. | https://banes-lab.com/json/records/lexicon/mitigation-plan | https://banes-lab.com/records/lexicon/mitigation-plan.md | 5410 | 4c2b5605300b566b3015afc1fe64f195174bc5fe3518339dc9463a92fef5ab95 |
| lexicon:accepted-risk-record | technique | Accepted Risk Record | A technique for recording a decision to accept a risk with who accepted it and when it is reviewed again. | https://banes-lab.com/json/records/lexicon/accepted-risk-record | https://banes-lab.com/records/lexicon/accepted-risk-record.md | 3142 | 54ad3ad13af537df4f5c8eb0e3f3bd3b3d5b50bfc60b033e556a442125717697 |
| lexicon:scheduled-review | technique | Scheduled Review | A technique for setting a date on which a decision, risk or exception is examined again. | https://banes-lab.com/json/records/lexicon/scheduled-review | https://banes-lab.com/records/lexicon/scheduled-review.md | 3119 | 4e3e2f6f2e6b27fa6ba1256f3a098e835a00e02bc519945a3b014642bd749100 |
| lexicon:risk-register | technique | Risk Register | A technique for keeping every known risk in one list with its owner, severity, mitigation and review date. | https://banes-lab.com/json/records/lexicon/risk-register | https://banes-lab.com/records/lexicon/risk-register.md | 3240 | c5ee2b4b28f2966b3d7b5778e3178e7760cba422dad3d4b8fa78b3e53cea225d |
| lexicon:decision-record-with-alternatives | technique | Decision Record with Alternatives | A technique for recording a decision together with the options rejected and the forces that decided it. | https://banes-lab.com/json/records/lexicon/decision-record-with-alternatives | https://banes-lab.com/records/lexicon/decision-record-with-alternatives.md | 4619 | a113feb8938d716c88650d1e14423b24a35a0eaf9f0326bf7ab6c2d4e2df5311 |
| lexicon:force-analysis | technique | Force Analysis | A technique for listing the pressures a design must balance before choosing a pattern for it. | https://banes-lab.com/json/records/lexicon/force-analysis | https://banes-lab.com/records/lexicon/force-analysis.md | 3201 | f1f2217cbcf8cd5f131eca765c4c3b4d059dfe6237e1fb446d45aa6bc9b7a3dc |
| lexicon:trade-off-matrix | technique | Trade-Off Matrix | A technique for scoring candidate designs against the quality attributes that matter for the decision. | https://banes-lab.com/json/records/lexicon/trade-off-matrix | https://banes-lab.com/records/lexicon/trade-off-matrix.md | 3128 | 6d3ad7bbaaf0c0e6f41ba4ec2d08b57d1aac41dc4a496b9d851df4417df0f199 |
| lexicon:quality-scenarios | technique | Quality Scenarios | A technique for stating each quality attribute as a stimulus, a response and a measure the design must meet. | https://banes-lab.com/json/records/lexicon/quality-scenarios | https://banes-lab.com/records/lexicon/quality-scenarios.md | 4160 | 92f45e2ebed7c946f470d602d0939052a439a8314af24da75212605fd2c59473 |
| lexicon:decision-review | technique | Decision Review | A technique for re-examining recorded decisions when the evidence behind them changes. | https://banes-lab.com/json/records/lexicon/decision-review | https://banes-lab.com/records/lexicon/decision-review.md | 4245 | 02a2f095646f726cb41e657b01a355c3e1e71fe111aca51e3220887b4f2413af |
| lexicon:vertical-slice-proof | technique | Vertical Slice Proof | A technique for proving a design by building one end-to-end path through every layer before generalizing it. | https://banes-lab.com/json/records/lexicon/vertical-slice-proof | https://banes-lab.com/records/lexicon/vertical-slice-proof.md | 3215 | d8d8d6d4702ababb945d0ce925416f83b3b62ea2f278f696f68774673167471f |
| lexicon:defer-generalization | technique | Defer Generalization | A technique for keeping concrete code until a second real variation shows what the abstraction must cover. | https://banes-lab.com/json/records/lexicon/defer-generalization | https://banes-lab.com/records/lexicon/defer-generalization.md | 4685 | 7a09a13047283a2289afffe8ce5103a481001d3eefac6e8b8fa6758712c99474 |
| lexicon:validate-required-forces | technique | Validate Required Forces | A technique for checking that a pattern in use has the boundary rules and contracts the pattern requires. | https://banes-lab.com/json/records/lexicon/validate-required-forces | https://banes-lab.com/records/lexicon/validate-required-forces.md | 3223 | 0661c55b844f470d7d3a96a8a802a5e43d50aceefbf7ef415dae081529f86552 |
| lexicon:track-rule-metrics | technique | Track Rule Metrics | A technique for counting violations of each architecture rule over time, so recurrence is visible. | https://banes-lab.com/json/records/lexicon/track-rule-metrics | https://banes-lab.com/records/lexicon/track-rule-metrics.md | 5021 | 1fd82924b8077766a3ad28a3319a01307dcacc1020cd0ffe95fbac7b4ceec889 |
| lexicon:architecture-test | technique | Architecture Test | A technique for expressing a structural rule, such as a dependency direction, as a test that runs in the build. | https://banes-lab.com/json/records/lexicon/architecture-test | https://banes-lab.com/records/lexicon/architecture-test.md | 4973 | 71fe2e82bdecfdf09dd705893943ab71f0b3be6ec5efce52250ae011bb337f4e |
| lexicon:remove-pattern-shell | technique | Remove Pattern Shell | A technique for deleting the structure of a pattern whose forces are absent, leaving the plain code it wrapped. | https://banes-lab.com/json/records/lexicon/remove-pattern-shell | https://banes-lab.com/records/lexicon/remove-pattern-shell.md | 4315 | e23b1bb10f16dbbcbc50b65f19b8eb8cdf498370c278aa7e03c218ae6bd27f31 |
| lexicon:duplicate-until-the-pattern-stabilizes | technique | Duplicate Until the Pattern Stabilizes | A technique for tolerating a small duplication until enough cases exist to show the shared shape. | https://banes-lab.com/json/records/lexicon/duplicate-until-the-pattern-stabilizes | https://banes-lab.com/records/lexicon/duplicate-until-the-pattern-stabilizes.md | 3301 | e7eb9b1c56495af10b45c0f75a6f818fa8ba347670fed76ade903f950f0b0881 |
| lexicon:measure-delivery-cost | technique | Measure Delivery Cost | A technique for measuring the time and effort an abstraction adds to delivering a change. | https://banes-lab.com/json/records/lexicon/measure-delivery-cost | https://banes-lab.com/records/lexicon/measure-delivery-cost.md | 3310 | 60b14f42b2af8c58dcdb55a86b2a1dc6d47e399883404a555cb93c0dad57b79a |
| lexicon:anchor-to-use-cases | technique | Anchor to Use Cases | A technique for justifying each component by a concrete use case it serves. | https://banes-lab.com/json/records/lexicon/anchor-to-use-cases | https://banes-lab.com/records/lexicon/anchor-to-use-cases.md | 3248 | ddea252d7fa91fda29bc0f3897a9b29e7602fbdce4165d2f552081c9afe64aff |
| lexicon:contextual-pattern-selection | technique | Contextual Pattern Selection | A technique for choosing a pattern by the forces of the problem at hand instead of by familiarity. | https://banes-lab.com/json/records/lexicon/contextual-pattern-selection | https://banes-lab.com/records/lexicon/contextual-pattern-selection.md | 3187 | 8a54722531b152660ba3545f8df959f98fd00a9135d1275bbdf0b41da6c75df4 |
| lexicon:dead-code-check | technique | Dead Code Check | A technique for failing the build on exports and branches that nothing reaches. | https://banes-lab.com/json/records/lexicon/dead-code-check | https://banes-lab.com/records/lexicon/dead-code-check.md | 3161 | bf38e9add24ced98288d7d87edb511daa898deb2ab80d61543560ba47a40f41e |
| lexicon:archive-reference | technique | Archive Reference | A technique for keeping removed code reachable in history or an archive instead of in the live tree. | https://banes-lab.com/json/records/lexicon/archive-reference | https://banes-lab.com/records/lexicon/archive-reference.md | 3160 | f263d8476306f12df4028896654db2193b785a4e35a76273c0886ec63ffdc532 |
| lexicon:inconsistent-conventions | anti-pattern | Inconsistent Conventions | A defect in which parts of one project use different structures, formats, tools or patterns for the same kind of thing. | https://banes-lab.com/json/records/lexicon/inconsistent-conventions | https://banes-lab.com/records/lexicon/inconsistent-conventions.md | 4445 | 0619a20abd905ae2585513918f5e821319ff97d5fdd58927cf025e712c30012e |
| lexicon:excessive-configuration | anti-pattern | Excessive Configuration | Requiring explicit configuration for everything instead of relying on sensible conventions. | https://banes-lab.com/json/records/lexicon/excessive-configuration | https://banes-lab.com/records/lexicon/excessive-configuration.md | 3457 | 52ea43450cbca0cb7846623396accf0a60346e31ec68db67da163cbab4e016c5 |
| lexicon:hardcoded-behavior | anti-pattern | Hardcoded Behavior | Hardcoding behavior in code instead of driving it from declarative metadata. | https://banes-lab.com/json/records/lexicon/hardcoded-behavior | https://banes-lab.com/records/lexicon/hardcoded-behavior.md | 3879 | 215405837ca9d02f55790eb04df93f327d5151caedffa97b79a792d38af60abf |
| lexicon:hardcoded-registration | anti-pattern | Hardcoded Registration | Registering components with hardcoded wiring instead of declaring them in a manifest. | https://banes-lab.com/json/records/lexicon/hardcoded-registration | https://banes-lab.com/records/lexicon/hardcoded-registration.md | 3402 | ceeb73438baff1e6c0e166bc9b02a95311d479893a4cd4e8b0e8d432302b5664 |
| lexicon:hidden-runtime-behavior | anti-pattern | Hidden Runtime Behavior | Behavior that is opaque at runtime because the system does not describe its own structure. | https://banes-lab.com/json/records/lexicon/hidden-runtime-behavior | https://banes-lab.com/records/lexicon/hidden-runtime-behavior.md | 4333 | 50751b2b8027961bd621fc6d9ce135a9ea75fa244077a6cec9339a989426203d |
| lexicon:implicit-capability | anti-pattern | Implicit Capability | Leaving what a component can do implicit and undiscoverable instead of declaring it. | https://banes-lab.com/json/records/lexicon/implicit-capability | https://banes-lab.com/records/lexicon/implicit-capability.md | 4206 | 4471fa6271c2a46be53d3816882fc965c0e8cff86f8c59dd4da3c00e768ff391 |
| lexicon:opaque-api | anti-pattern | Opaque API | An API that does not describe itself, so clients must rely on external, out-of-band documentation. | https://banes-lab.com/json/records/lexicon/opaque-api | https://banes-lab.com/records/lexicon/opaque-api.md | 3854 | 87beacc374f33d4b5fadeb559457107faf95c7dc4deceb199c842efe6679cf08 |
| lexicon:opaque-binary-untyped-structures | anti-pattern | Opaque Binary/Untyped Structures | Using opaque binary or untyped data that carries no description of its own structure. | https://banes-lab.com/json/records/lexicon/opaque-binary-untyped-structures | https://banes-lab.com/records/lexicon/opaque-binary-untyped-structures.md | 3879 | 4db24170139cc58f7b01102729c0f73d9dc04d88f0af02444ed8a1547e02ebeb |
| lexicon:client-generation | capability | Client Generation | The ability to generate client code automatically from an API's self-description. | https://banes-lab.com/json/records/lexicon/client-generation | https://banes-lab.com/records/lexicon/client-generation.md | 3411 | 3ee40b8923993452e3fc7b1f57d54fdb4c655c42fd436e0726e77abacb3fbd72 |
| lexicon:dynamic-processing | capability | Dynamic Processing | The ability to process data generically by reading its self-describing structure. | https://banes-lab.com/json/records/lexicon/dynamic-processing | https://banes-lab.com/records/lexicon/dynamic-processing.md | 3405 | aee178ae73a66131eec897f55e33b32c3964d7cfcb07019e773f3e9a284161cc |