# Lexicon terms whose kind is technique

> 285 records

This index as JSON: https://banes-lab.com/json/api/facets/lexicon/kind/technique

## Entries

- [Map to Domain Model](https://banes-lab.com/records/lexicon/map-to-domain-model.md): A technique for translating external or persistence data into domain types at the boundary.
- [Move Logic to the Domain](https://banes-lab.com/records/lexicon/move-logic-to-the-domain.md): A technique for moving business rules out of controllers, services and scripts into the domain objects they govern.
- [Extract Use Case](https://banes-lab.com/records/lexicon/extract-use-case.md): A technique for moving one business operation into an application service that coordinates the domain and its ports.
- [Extract Domain Model](https://banes-lab.com/records/lexicon/extract-domain-model.md): A technique for turning procedural steps over data into domain types that hold their own rules.
- [Extract Query Service](https://banes-lab.com/records/lexicon/extract-query-service.md): A technique for moving read-only, use-case-specific queries out of a repository into a query service.
- [Split Repository](https://banes-lab.com/records/lexicon/split-repository.md): A technique for reducing a repository to persistence of one aggregate and moving everything else out of it.
- [Add Aggregate Invariant](https://banes-lab.com/records/lexicon/add-aggregate-invariant.md): A technique for enforcing a rule across related entities inside the aggregate that owns them.
- [Split Bounded Context](https://banes-lab.com/records/lexicon/split-bounded-context.md): A technique for dividing a model that serves several meanings into contexts that each own one meaning of their terms.
- [Replace Conditional with Polymorphism](https://banes-lab.com/records/lexicon/replace-conditional-with-polymorphism.md): Replacing a branching conditional on type with polymorphic dispatch through a shared interface.
- [Discovery Validation](https://banes-lab.com/records/lexicon/discovery-validation.md): A technique for checking at startup that every discovered component declares the contract it claims.
- [Reorder Buffer](https://banes-lab.com/records/lexicon/reorder-buffer.md): A technique for holding events that arrive early until the events before them arrive, then releasing them in order.
- [Standard Error Contract](https://banes-lab.com/records/lexicon/standard-error-contract.md): A technique for giving every error one published shape with a code, a message and its context.
- [Introduce Boundary DTO](https://banes-lab.com/records/lexicon/introduce-boundary-dto.md): A technique for carrying data across a boundary in a transfer object, so internal models stay inside.
- [Coarse-Grained Endpoint](https://banes-lab.com/records/lexicon/coarse-grained-endpoint.md): A technique for serving one client operation with one call that returns everything the operation needs.
- [Backward-Compatible Change](https://banes-lab.com/records/lexicon/backward-compatible-change.md): A technique for changing a contract only by additions that existing consumers can ignore.
- [Compatibility Adapter](https://banes-lab.com/records/lexicon/compatibility-adapter.md): A technique for serving an old contract through an adapter over the new one while consumers migrate.
- [Gradual Deprecation](https://banes-lab.com/records/lexicon/gradual-deprecation.md): A technique for announcing a removal with a date, warning the consumers still using it, and removing it after the date.
- [Migration Guide](https://banes-lab.com/records/lexicon/migration-guide.md): A technique for publishing the steps a consumer takes to move from one version of a contract to the next.
- [Version Bump](https://banes-lab.com/records/lexicon/version-bump.md): A technique for raising a contract's version number by the rule that says which kind of change it carries.
- [Consumer-Driven Contract Tests](https://banes-lab.com/records/lexicon/consumer-driven-contract-tests.md): A technique for having each consumer publish the responses it relies on and testing the provider against all of them before it releases.
- [Define Contract](https://banes-lab.com/records/lexicon/define-contract.md): A technique for publishing the operations, shapes and guarantees of a boundary before implementing either side of it.
- [Standardize the Interface](https://banes-lab.com/records/lexicon/standardize-the-interface.md): A technique for giving operations of one kind the same naming, shapes and conventions across a system.
- [Tolerant Reader](https://banes-lab.com/records/lexicon/tolerant-reader.md): A technique for reading only the fields a consumer needs and ignoring unknown ones, so additive changes do not break it.
- [Externalize Configuration](https://banes-lab.com/records/lexicon/externalize-configuration.md): A technique for moving values that vary by environment out of code into configuration read at startup.
- [Configuration Schema](https://banes-lab.com/records/lexicon/configuration-schema.md): A technique for validating configuration against a declared schema before the system starts.
- [Make Effects Explicit](https://banes-lab.com/records/lexicon/make-effects-explicit.md): A technique for moving input, output and mutation to named boundary operations, so the code between them stays pure.
- [Pass Context Explicitly](https://banes-lab.com/records/lexicon/pass-context-explicitly.md): A technique for passing request, user or tenant context as a parameter or scoped object instead of reading it from global state.
- [Inject Clock and Randomness](https://banes-lab.com/records/lexicon/inject-clock-and-randomness.md): A technique for supplying time and random values through parameters, so the code under test runs the same way every time.
- [Test Observable Behavior](https://banes-lab.com/records/lexicon/test-observable-behavior.md): A technique for asserting on a unit's outputs and effects instead of on the internal calls it makes.
- [Fake at the Boundary](https://banes-lab.com/records/lexicon/fake-at-the-boundary.md): A technique for replacing an external dependency in tests with a working in-memory implementation of its port.
- [Unit Tests](https://banes-lab.com/records/lexicon/unit-tests.md): A technique for testing one unit of behavior in isolation, fast enough to run on every change.
- [Component Tests](https://banes-lab.com/records/lexicon/component-tests.md): A technique for testing one deployable component through its public interface with its dependencies replaced.
- [Isolate Test State](https://banes-lab.com/records/lexicon/isolate-test-state.md): A technique for giving each test its own data and resources, so tests pass in any order.
- [Validate at the Boundary](https://banes-lab.com/records/lexicon/validate-at-the-boundary.md): A technique for rejecting malformed input where it enters the system, so the core receives only valid values.
- [Encapsulate Validation](https://banes-lab.com/records/lexicon/encapsulate-validation.md): A technique for placing a value's validation in the type that holds it, so every instance is valid.
- [Validate as a Group](https://banes-lab.com/records/lexicon/validate-as-a-group.md): A technique for validating fields that depend on each other together, in the object that groups them.
- [Precondition Check](https://banes-lab.com/records/lexicon/precondition-check.md): A technique for checking at the start of an operation that the state and arguments it requires hold.
- [Invariant Check](https://banes-lab.com/records/lexicon/invariant-check.md): A technique for checking after each change that the rules a state must always satisfy still hold.
- [Postcondition Check](https://banes-lab.com/records/lexicon/postcondition-check.md): A technique for checking at the end of an operation that the result and state it promises hold.
- [Pin Versions](https://banes-lab.com/records/lexicon/pin-versions.md): A technique for recording exact versions of dependencies and tools, so every build uses the same inputs.
- [Delegation](https://banes-lab.com/records/lexicon/delegation.md): Forwarding work to a contained collaborator object rather than inheriting the behavior.
- [Extract Class](https://banes-lab.com/records/lexicon/extract-class.md): A technique for moving a cohesive group of fields and methods out of a class into a new class of their own.
- [Extract Module](https://banes-lab.com/records/lexicon/extract-module.md): A technique for moving one responsibility out of a module into a new module with its own entry point.
- [Split Module](https://banes-lab.com/records/lexicon/split-module.md): A technique for dividing a module into modules that each hold one reason to change.
- [Move Behavior to Its Owner](https://banes-lab.com/records/lexicon/move-behavior-to-its-owner.md): A technique for moving a method or function to the module that owns the data it reads and writes.
- [Extract Function](https://banes-lab.com/records/lexicon/extract-function.md): A technique for moving a fragment of a long function into a named function of its own.
- [Split Method](https://banes-lab.com/records/lexicon/split-method.md): A technique for dividing a method that branches on a flag into one method per behavior.
- [Inline Abstraction](https://banes-lab.com/records/lexicon/inline-abstraction.md): A technique for removing an interface, layer or wrapper that adds no policy and calling its single implementation directly.
- [Hide Delegate](https://banes-lab.com/records/lexicon/hide-delegate.md): A technique for adding a method on an object that forwards to the object behind it, so clients stop navigating the chain.
- [Encapsulate State](https://banes-lab.com/records/lexicon/encapsulate-state.md): A technique for making a module's state private and exposing only operations that keep its rules.
- [Restrict Exports](https://banes-lab.com/records/lexicon/restrict-exports.md): A technique for narrowing a module's public surface to the operations its consumers need.
- [Introduce Parameter Object](https://banes-lab.com/records/lexicon/introduce-parameter-object.md): A technique for replacing a group of parameters that travel together with one named object.
- [Separate Query from Command](https://banes-lab.com/records/lexicon/separate-query-from-command.md): A technique for splitting an operation that both returns data and changes state into a query and a command.
- [Collapse Layers](https://banes-lab.com/records/lexicon/collapse-layers.md): A technique for merging layers that only pass calls through, so a simple operation crosses fewer boundaries.
- [Preserve Only Real Boundaries](https://banes-lab.com/records/lexicon/preserve-only-real-boundaries.md): A technique for keeping an abstraction only where it separates parts that change for different reasons.
- [Split by Domain](https://banes-lab.com/records/lexicon/split-by-domain.md): A technique for dividing a catch-all module into modules named for the domain concepts they serve.
- [Centralize the Rule](https://banes-lab.com/records/lexicon/centralize-the-rule.md): A technique for gathering every copy of one rule into a single definition that the copies are replaced by.
- [Explicit Dependency](https://banes-lab.com/records/lexicon/explicit-dependency.md): A technique for declaring what a module needs as parameters or imports instead of reaching it through global state.
- [Localize Effect](https://banes-lab.com/records/lexicon/localize-effect.md): A technique for confining a change of global behavior to the scope that needs it.
- [Restrict Global Mutation](https://banes-lab.com/records/lexicon/restrict-global-mutation.md): A technique for forbidding writes to global objects outside one owning module.
- [Split Abstraction](https://banes-lab.com/records/lexicon/split-abstraction.md): A technique for dividing an abstraction that grew flags for each caller into abstractions that fit one use each.
- [Define Module Boundaries](https://banes-lab.com/records/lexicon/define-module-boundaries.md): A technique for declaring which module owns each piece of code and which entry points other modules may use.
- [Extract Interface](https://banes-lab.com/records/lexicon/extract-interface.md): A technique for declaring the operations clients use as an interface, so the clients depend on it instead of on the class.
- [Extract Role Interface](https://banes-lab.com/records/lexicon/extract-role-interface.md): A technique for splitting the operations one client role uses into an interface of their own.
- [Split Interface](https://banes-lab.com/records/lexicon/split-interface.md): A technique for dividing a broad interface into smaller ones, each holding operations that change together.
- [Replace Inheritance with Delegation](https://banes-lab.com/records/lexicon/replace-inheritance-with-delegation.md): A technique for replacing a subclass with a class that holds the former base as a field and forwards to it.
- [Split Hierarchy](https://banes-lab.com/records/lexicon/split-hierarchy.md): A technique for dividing a class hierarchy whose subtypes do not honor one contract into hierarchies that each do.
- [Invert Dependency](https://banes-lab.com/records/lexicon/invert-dependency.md): A technique for making a high-level module own an abstraction that a low-level module implements.
- [Query Projection](https://banes-lab.com/records/lexicon/query-projection.md): A technique for maintaining a read model shaped for one query, updated from the writes it depends on.
- [Introduce Async Event](https://banes-lab.com/records/lexicon/introduce-async-event.md): A technique for replacing a synchronous call that need not complete in the request with an event a consumer handles later.
- [Own Data per Service](https://banes-lab.com/records/lexicon/own-data-per-service.md): A technique for giving each service its own store and letting others reach the data only through its contract.
- [Offset Tracking](https://banes-lab.com/records/lexicon/offset-tracking.md): A technique for recording how far each consumer has read in a stream, so it resumes there and can replay from earlier.
- [Snapshot Compaction](https://banes-lab.com/records/lexicon/snapshot-compaction.md): A technique for periodically storing a snapshot of state derived from a log, so readers replay only the events after it.
- [Backoff](https://banes-lab.com/records/lexicon/backoff.md): Progressively increasing the wait between retries to avoid overwhelming a recovering dependency.
- [Introduce Typed Result](https://banes-lab.com/records/lexicon/introduce-typed-result.md): A technique for returning success or a typed error as a value, so callers handle failure through the type system.
- [Translate Errors at the Boundary](https://banes-lab.com/records/lexicon/translate-errors-at-the-boundary.md): A technique for converting vendor and infrastructure errors into the core's own error types where they enter.
- [Idempotency Key](https://banes-lab.com/records/lexicon/idempotency-key.md): A technique for tagging each request with a unique key, so a repeated request is recognized and applied once.
- [Bounded Retry](https://banes-lab.com/records/lexicon/bounded-retry.md): A technique for retrying a failed call a limited number of times with growing delays before giving up.
- [Jitter](https://banes-lab.com/records/lexicon/jitter.md): A technique for adding a random offset to retry delays, so clients that failed together do not retry together.
- [Deadline Propagation](https://banes-lab.com/records/lexicon/deadline-propagation.md): 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.
- [Cancellation](https://banes-lab.com/records/lexicon/cancellation.md): A technique for letting a caller stop work it no longer needs, releasing the resources that work holds.
- [Load Shedding](https://banes-lab.com/records/lexicon/load-shedding.md): A technique for refusing part of the incoming work when load passes capacity, so the work already accepted completes.
- [Bounded Queue](https://banes-lab.com/records/lexicon/bounded-queue.md): A technique for giving a queue a fixed capacity, so producers are slowed or refused instead of exhausting memory.
- [Fail Fast or Fall Back](https://banes-lab.com/records/lexicon/fail-fast-or-fall-back.md): A technique for deciding per failure whether to stop with an error at once or to continue on a declared fallback.
- [Delete After Evidence](https://banes-lab.com/records/lexicon/delete-after-evidence.md): A technique for removing code once measurement shows nothing calls it.
- [Deprecation Plan](https://banes-lab.com/records/lexicon/deprecation-plan.md): A technique for recording for each obsolete path its owner, its replacement and its removal date.
- [Assign Owner](https://banes-lab.com/records/lexicon/assign-owner.md): A technique for recording a named owner for each module, risk or rule, who decides on its changes.
- [Severity Classification](https://banes-lab.com/records/lexicon/severity-classification.md): A technique for ranking each finding or risk on a declared scale that sets how soon it is handled.
- [Mitigation Plan](https://banes-lab.com/records/lexicon/mitigation-plan.md): A technique for recording the actions that reduce a risk, with an owner and a date for each.
- [Accepted Risk Record](https://banes-lab.com/records/lexicon/accepted-risk-record.md): A technique for recording a decision to accept a risk with who accepted it and when it is reviewed again.
- [Scheduled Review](https://banes-lab.com/records/lexicon/scheduled-review.md): A technique for setting a date on which a decision, risk or exception is examined again.
- [Risk Register](https://banes-lab.com/records/lexicon/risk-register.md): A technique for keeping every known risk in one list with its owner, severity, mitigation and review date.
- [Decision Record with Alternatives](https://banes-lab.com/records/lexicon/decision-record-with-alternatives.md): A technique for recording a decision together with the options rejected and the forces that decided it.
- [Force Analysis](https://banes-lab.com/records/lexicon/force-analysis.md): A technique for listing the pressures a design must balance before choosing a pattern for it.
- [Trade-Off Matrix](https://banes-lab.com/records/lexicon/trade-off-matrix.md): A technique for scoring candidate designs against the quality attributes that matter for the decision.
- [Quality Scenarios](https://banes-lab.com/records/lexicon/quality-scenarios.md): A technique for stating each quality attribute as a stimulus, a response and a measure the design must meet.
- [Decision Review](https://banes-lab.com/records/lexicon/decision-review.md): A technique for re-examining recorded decisions when the evidence behind them changes.
- [Vertical Slice Proof](https://banes-lab.com/records/lexicon/vertical-slice-proof.md): A technique for proving a design by building one end-to-end path through every layer before generalizing it.
- [Defer Generalization](https://banes-lab.com/records/lexicon/defer-generalization.md): A technique for keeping concrete code until a second real variation shows what the abstraction must cover.
- [Validate Required Forces](https://banes-lab.com/records/lexicon/validate-required-forces.md): A technique for checking that a pattern in use has the boundary rules and contracts the pattern requires.
- [Track Rule Metrics](https://banes-lab.com/records/lexicon/track-rule-metrics.md): A technique for counting violations of each architecture rule over time, so recurrence is visible.
- [Architecture Test](https://banes-lab.com/records/lexicon/architecture-test.md): A technique for expressing a structural rule, such as a dependency direction, as a test that runs in the build.
- [Remove Pattern Shell](https://banes-lab.com/records/lexicon/remove-pattern-shell.md): A technique for deleting the structure of a pattern whose forces are absent, leaving the plain code it wrapped.
- [Duplicate Until the Pattern Stabilizes](https://banes-lab.com/records/lexicon/duplicate-until-the-pattern-stabilizes.md): A technique for tolerating a small duplication until enough cases exist to show the shared shape.
- [Measure Delivery Cost](https://banes-lab.com/records/lexicon/measure-delivery-cost.md): A technique for measuring the time and effort an abstraction adds to delivering a change.
- [Anchor to Use Cases](https://banes-lab.com/records/lexicon/anchor-to-use-cases.md): A technique for justifying each component by a concrete use case it serves.
- [Contextual Pattern Selection](https://banes-lab.com/records/lexicon/contextual-pattern-selection.md): A technique for choosing a pattern by the forces of the problem at hand instead of by familiarity.
- [Dead Code Check](https://banes-lab.com/records/lexicon/dead-code-check.md): A technique for failing the build on exports and branches that nothing reaches.
- [Archive Reference](https://banes-lab.com/records/lexicon/archive-reference.md): A technique for keeping removed code reachable in history or an archive instead of in the live tree.
- [Runtime Topology Report](https://banes-lab.com/records/lexicon/runtime-topology-report.md): A technique for having a system report its loaded components and their bindings at startup.
- [Binding Decision Log](https://banes-lab.com/records/lexicon/binding-decision-log.md): A technique for logging which implementation was bound to each extension point and why.
- [Declare Capability](https://banes-lab.com/records/lexicon/declare-capability.md): A technique for having each component state in metadata what it provides and what it requires.
- [Runtime Dynamic Evaluation](https://banes-lab.com/records/lexicon/runtime-dynamic-evaluation.md): Evaluating code or expressions dynamically at runtime, trading compile-time checking for runtime flexibility.
- [Syntax Tree Generation](https://banes-lab.com/records/lexicon/syntax-tree-generation.md): A technique for generating code by building and printing a syntax tree instead of concatenating strings.
- [Prompt Registry](https://banes-lab.com/records/lexicon/prompt-registry.md): A technique for keeping prompts in one versioned registry instead of as literals across the code.
- [Prompt Versioning](https://banes-lab.com/records/lexicon/prompt-versioning.md): A technique for giving each prompt, dataset and index a version that inference logs record.
- [Evaluation Suite](https://banes-lab.com/records/lexicon/evaluation-suite.md): A technique for scoring model output against a fixed set of cases on every change to the model, prompt or data.
- [Centralized Model Configuration](https://banes-lab.com/records/lexicon/centralized-model-configuration.md): A technique for holding model names, parameters and limits in one configuration read by every call site.
- [Inference Context Record](https://banes-lab.com/records/lexicon/inference-context-record.md): A technique for logging with each model output the model version, prompt version and inputs that produced it.
- [Evidence Citation](https://banes-lab.com/records/lexicon/evidence-citation.md): A technique for attaching to each generated claim the retrieved source that supports it.
- [Claim Validation](https://banes-lab.com/records/lexicon/claim-validation.md): A technique for checking generated claims against their cited sources before they are returned.
- [Abstain or Disclose Uncertainty](https://banes-lab.com/records/lexicon/abstain-or-disclose-uncertainty.md): A technique for having a model decline or state its uncertainty when the evidence does not support an answer.
- [Governance Log](https://banes-lab.com/records/lexicon/governance-log.md): A technique for recording each approval, deployment and retirement of a model with who decided it.
- [Structured Log](https://banes-lab.com/records/lexicon/structured-log.md): A technique for writing log entries as typed fields, so they are queried by field instead of by text.
- [Trace Span](https://banes-lab.com/records/lexicon/trace-span.md): A technique for recording the start, end and context of an operation as a span within a request's trace.
- [Alert on Critical Failure](https://banes-lab.com/records/lexicon/alert-on-critical-failure.md): A technique for raising an alert with an owner and a severity when a critical path fails.
- [Cardinality Reduction](https://banes-lab.com/records/lexicon/cardinality-reduction.md): A technique for limiting the distinct label values a metric carries, so its storage and queries stay bounded.
- [Sampling and Aggregation](https://banes-lab.com/records/lexicon/sampling-and-aggregation.md): A technique for keeping a representative share of telemetry or a summary of it instead of every event.
- [Runbook Owner](https://banes-lab.com/records/lexicon/runbook-owner.md): A technique for naming the person or team responsible for each alert and its response steps.
- [Causation Tracing](https://banes-lab.com/records/lexicon/causation-tracing.md): A technique for carrying the id of the event or request that caused each effect, so a chain can be followed back.
- [Usage Instrumentation](https://banes-lab.com/records/lexicon/usage-instrumentation.md): A technique for counting calls to a code path in production, so its use is measured before it is removed.
- [Data Change Audit](https://banes-lab.com/records/lexicon/data-change-audit.md): A technique for recording who changed which data, when, and from what value to what value.
- [Execution Log](https://banes-lab.com/records/lexicon/execution-log.md): A technique for recording each step an automated or manual procedure performed and its result.
- [Define Signal Quality](https://banes-lab.com/records/lexicon/define-signal-quality.md): A technique for stating what makes a log, metric or alert useful before it is emitted.
- [Service Level Objectives](https://banes-lab.com/records/lexicon/service-level-objectives.md): A technique for choosing measured indicators of reliability and setting the targets a service must meet on them.
- [Encode State Machine](https://banes-lab.com/records/lexicon/encode-state-machine.md): A technique for declaring the states and legal transitions of a lifecycle, so an operation called in the wrong state is refused.
- [Make Order Explicit](https://banes-lab.com/records/lexicon/make-order-explicit.md): A technique for expressing a required call order in types or a state machine instead of in documentation.
- [Constructor-Valid State](https://banes-lab.com/records/lexicon/constructor-valid-state.md): A technique for having a constructor or factory accept only arguments that produce a valid object.
- [Session Affinity](https://banes-lab.com/records/lexicon/session-affinity.md): Routing all of a client's requests to the same server instance so its session state stays local.
- [Cache Contract](https://banes-lab.com/records/lexicon/cache-contract.md): A technique for declaring what a cache entry is keyed by, how long it lives and what invalidates it.
- [Context-Keyed Cache](https://banes-lab.com/records/lexicon/context-keyed-cache.md): A technique for including tenant, identity, version and every input that changes the result in a cache key.
- [Cache Invalidation on Write](https://banes-lab.com/records/lexicon/cache-invalidation-on-write.md): A technique for removing or refreshing cached entries in the same change that writes the data behind them.
- [Batch Fetch](https://banes-lab.com/records/lexicon/batch-fetch.md): A technique for loading the related data for many items in one query or call instead of one per item.
- [Externalize Session State](https://banes-lab.com/records/lexicon/externalize-session-state.md): A technique for moving per-user or per-request state out of instance memory into a shared store.
- [Replace Algorithm](https://banes-lab.com/records/lexicon/replace-algorithm.md): A technique for swapping an algorithm or data structure for one with better complexity for the inputs at hand.
- [Add Index](https://banes-lab.com/records/lexicon/add-index.md): A technique for adding an index on the fields a slow query filters or sorts by.
- [Chunked Processing](https://banes-lab.com/records/lexicon/chunked-processing.md): A technique for processing large data in fixed-size pieces, so memory use stays bounded.
- [Multi-Pass Full Materialization](https://banes-lab.com/records/lexicon/multi-pass-full-materialization.md): Loading a full dataset into memory and traversing it in multiple passes, rather than in a single streaming pass.
- [Eager Full Materialization](https://banes-lab.com/records/lexicon/eager-full-materialization.md): Computing and materializing a complete result up front, rather than deferring computation until parts are needed.
- [Backtracking Algorithm](https://banes-lab.com/records/lexicon/backtracking-algorithm.md): A method that explores options and reverts to an earlier point when one fails, requiring the ability to look back.
- [Fuse Passes](https://banes-lab.com/records/lexicon/fuse-passes.md): A technique for combining several passes over the same data into one.
- [Recovery Policy](https://banes-lab.com/records/lexicon/recovery-policy.md): A technique for declaring, per failure class, the action the system takes to restore service and who is told.
- [Expand-Contract Migration](https://banes-lab.com/records/lexicon/expand-contract-migration.md): A technique for changing a schema in steps, adding the new shape, moving every reader and writer, then removing the old shape.
- [Dual Read and Write](https://banes-lab.com/records/lexicon/dual-read-and-write.md): A technique for writing to both the old and the new store and comparing reads during a migration, until the new store is trusted.
- [Rollback Plan](https://banes-lab.com/records/lexicon/rollback-plan.md): A technique for stating before a release how it is undone and testing that the undo works.
- [Small-Batch Release](https://banes-lab.com/records/lexicon/small-batch-release.md): A technique for shipping changes in small increments, so each release has a small blast radius.
- [Backup](https://banes-lab.com/records/lexicon/backup.md): A technique for copying data to separate storage on a schedule, so it can be restored after loss or corruption.
- [Automate the Runbook](https://banes-lab.com/records/lexicon/automate-the-runbook.md): A technique for turning repeated manual operational steps into a script the system runs and logs.
- [Autoscaling Policy](https://banes-lab.com/records/lexicon/autoscaling-policy.md): A technique for declaring the load signals and limits by which the number of instances grows and shrinks.
- [Introduce Discriminated Union](https://banes-lab.com/records/lexicon/introduce-discriminated-union.md): A technique for modeling a value that takes one of several shapes as a union whose variants carry a tag the type checker reads.
- [Narrow Type](https://banes-lab.com/records/lexicon/narrow-type.md): A technique for replacing a broad type with one that admits only the values the domain allows.
- [Define Absence Semantics](https://banes-lab.com/records/lexicon/define-absence-semantics.md): A technique for choosing one representation for a missing value and stating what it means at the boundary.
- [Binary Schema Encoding](https://banes-lab.com/records/lexicon/binary-schema-encoding.md): A technique for serializing messages in a compact binary format whose schema the reader and writer share.
- [Schema Registry](https://banes-lab.com/records/lexicon/schema-registry.md): A technique for storing every published schema and its versions in one registry that producers and consumers check against.
- [Context-Aware Encoding](https://banes-lab.com/records/lexicon/context-aware-encoding.md): Choosing an output encoding matched to the destination context, such as HTML, an attribute, a URL or a script, so data is neutralized wherever it lands.
- [Query Parameter Binding](https://banes-lab.com/records/lexicon/query-parameter-binding.md): Passing query values as bound parameters separate from the query text, so input can never alter the query structure.
- [Request Origin Verification](https://banes-lab.com/records/lexicon/request-origin-verification.md): Confirming that a state-changing request originates from a trusted client, typically via a token or origin check.
- [Remove Secret from Code](https://banes-lab.com/records/lexicon/remove-secret-from-code.md): A technique for deleting a credential from source and history and reading it from a secret store instead.
- [Secret Rotation](https://banes-lab.com/records/lexicon/secret-rotation.md): A technique for replacing credentials on a schedule and after any exposure, so a leaked secret stops working.
- [Least-Privilege Credential](https://banes-lab.com/records/lexicon/least-privilege-credential.md): A technique for issuing each caller a credential that grants only the operations it performs.
- [Centralize Policy](https://banes-lab.com/records/lexicon/centralize-policy.md): A technique for evaluating every authorization decision through one policy model instead of scattered checks.
- [Server-Side Enforcement](https://banes-lab.com/records/lexicon/server-side-enforcement.md): A technique for enforcing every security rule on the server, whatever the client checks.
- [Penetration Testing](https://banes-lab.com/records/lexicon/penetration-testing.md): A technique for attacking a system under agreement to find the paths that bypass its controls.
- [Authorization Tests](https://banes-lab.com/records/lexicon/authorization-tests.md): A technique for testing each protected operation with permitted and refused identities.
- [Field Redaction](https://banes-lab.com/records/lexicon/field-redaction.md): A technique for removing or masking sensitive fields before data is logged, exported or displayed.
- [Purpose Binding](https://banes-lab.com/records/lexicon/purpose-binding.md): A technique for tagging personal data with the purpose it was collected for and refusing uses outside it.
- [Retention Policy](https://banes-lab.com/records/lexicon/retention-policy.md): A technique for declaring how long each class of data is kept and deleting it when the period ends.
- [Repository Secret Scan](https://banes-lab.com/records/lexicon/repository-secret-scan.md): A technique for scanning source and history for credentials before a change is accepted.
- [Default Deny](https://banes-lab.com/records/lexicon/default-deny.md): A technique for refusing every access that no rule explicitly allows.
- [Sandboxing](https://banes-lab.com/records/lexicon/sandboxing.md): A technique for running untrusted code with only the resources and permissions it is granted.
- [Network Segmentation](https://banes-lab.com/records/lexicon/network-segmentation.md): A technique for dividing a network into zones whose traffic between them passes declared controls.
- [Introduce Port](https://banes-lab.com/records/lexicon/introduce-port.md): A technique for declaring an interface owned by the core that names what it needs from the outside world.
- [Extract Adapter](https://banes-lab.com/records/lexicon/extract-adapter.md): A technique for moving the code that talks to a framework, vendor or protocol into an adapter behind a port.
- [Move Framework Outward](https://banes-lab.com/records/lexicon/move-framework-outward.md): A technique for removing framework types and annotations from the core and confining them to adapters.
- [Repackage by Feature](https://banes-lab.com/records/lexicon/repackage-by-feature.md): A technique for moving the code of one feature from technical-layer folders into one folder of its own.
- [Name the Objector](https://banes-lab.com/records/lexicon/name-the-objector.md): A technique for naming, for each stated invariant, the party or check that objects when it stops holding.
- [Mark the Invariant Unheld](https://banes-lab.com/records/lexicon/mark-the-invariant-unheld.md): A technique for marking an invariant that nothing enforces as unheld, together with every derivation that rests on it.
- [Derive State from Edges](https://banes-lab.com/records/lexicon/derive-state-from-edges.md): A technique for removing a written status field and computing a record's state from the edges that connect it.
- [Allocate Identity Once](https://banes-lab.com/records/lexicon/allocate-identity-once.md): A technique for assigning a record its id when it is created and never deriving it again from its location or subject.
- [Declare the Subject Beside the Id](https://banes-lab.com/records/lexicon/declare-the-subject-beside-the-id.md): A technique for recording a record's subject as a declared field next to its id, so either can change without breaking the other.
- [Hold the Barrier for Planned Writes](https://banes-lab.com/records/lexicon/hold-the-barrier-for-planned-writes.md): A technique for taking an exclusive write on a shared surface only after every peer is observed parked.
- [Declare the Missing Operand](https://banes-lab.com/records/lexicon/declare-the-missing-operand.md): A technique for declaring on a jointly authored surface that the one-writer invariant has no operand there.
- [Settle Collisions by Announcement](https://banes-lab.com/records/lexicon/settle-collisions-by-announcement.md): A technique for resolving concurrent work on a jointly authored surface by each party announcing its claim before acting.
- [Refresh the Projection in the Same Change](https://banes-lab.com/records/lexicon/refresh-the-projection-in-the-same-change.md): A technique for updating a projection in the same change that moves the fact it summarizes.
- [Check the Projection's Shape](https://banes-lab.com/records/lexicon/check-the-projection-s-shape.md): A technique for checking that a projection holds only the shape its name claims.
- [Generate the Index from the Directory](https://banes-lab.com/records/lexicon/generate-the-index-from-the-directory.md): A technique for producing an index by reading the directory it describes instead of editing entries by hand.
- [Check Both Directions](https://banes-lab.com/records/lexicon/check-both-directions.md): A technique for checking that every index entry resolves to a file and that every file has an entry.
- [Declare All Three Lifetime Axes](https://banes-lab.com/records/lexicon/declare-all-three-lifetime-axes.md): A technique for declaring each surface's lifetime with a value from the closed set of every axis, so no axis is inferred.
- [Declare the File Default](https://banes-lab.com/records/lexicon/declare-the-file-default.md): A technique for stating the lifetime a file's sections take unless a section declares its own.
- [Declare Each Divergent Section](https://banes-lab.com/records/lexicon/declare-each-divergent-section.md): A technique for declaring the lifetime of every section that lives differently from its file's default.
- [Declare the Write Scope](https://banes-lab.com/records/lexicon/declare-the-write-scope.md): A technique for publishing the part of a surface a run writes, so overlapping runs are detected.
- [Publish the Read Population](https://banes-lab.com/records/lexicon/publish-the-read-population.md): A technique for publishing what a run read, so a later question can tell whether the run's result answers it.
- [Test Coverage First](https://banes-lab.com/records/lexicon/test-coverage-first.md): A technique for checking whether a live run's scope already covers a question before starting a new run.
- [Join by Reading the Published Result](https://banes-lab.com/records/lexicon/join-by-reading-the-published-result.md): A technique for waiting on another run by reading the result it publishes instead of attaching to its process.
- [Derive Liveness Once](https://banes-lab.com/records/lexicon/derive-liveness-once.md): A technique for computing liveness in one place that every consumer reads.
- [Witness First](https://banes-lab.com/records/lexicon/witness-first.md): A technique for deciding liveness from a witness the process writes, never from the process being present.
- [Window Second](https://banes-lab.com/records/lexicon/window-second.md): A technique for applying a time window to a liveness witness only after the witness is read.
- [Encode the Scope Reversibly](https://banes-lab.com/records/lexicon/encode-the-scope-reversibly.md): A technique for naming a channel by an encoding of its scope that can be decoded back to the scope.
- [Declare the Remover](https://banes-lab.com/records/lexicon/declare-the-remover.md): A technique for recording which party removes a channel, so every channel has a party that can attribute it.
- [Write the Entry Before Reading the Set](https://banes-lab.com/records/lexicon/write-the-entry-before-reading-the-set.md): A technique for writing a run's own entry before reading the set of live runs, so two starters see each other.
- [Count Distinguished Copies](https://banes-lab.com/records/lexicon/count-distinguished-copies.md): A technique for counting the copies that differ from their source before deciding which way to collapse them.
- [Read Each Period](https://banes-lab.com/records/lexicon/read-each-period.md): A technique for checking, for each copy, whether the edge that produced it runs again or ran once against an earlier state.
- [Repair the Source](https://banes-lab.com/records/lexicon/repair-the-source.md): A technique for fixing a defect at the source every copy derives from instead of in the copies.
- [Derive the Partition](https://banes-lab.com/records/lexicon/derive-the-partition.md): A technique for deriving the partition of work from the surfaces involved before choosing how many parties take part.
- [Count the Partition's Concerns](https://banes-lab.com/records/lexicon/count-the-partition-s-concerns.md): A technique for setting the party count to the number of concerns the derived partition holds.
- [Mark Claims with Their Read Moment](https://banes-lab.com/records/lexicon/mark-claims-with-their-read-moment.md): A technique for stamping each claim with the moment its surface was read, so a stale claim is recognized.
- [Partition the Surface](https://banes-lab.com/records/lexicon/partition-the-surface.md): A technique for dividing a surface that too many parties reason about into surfaces with fewer readers each.
- [Retain the Prior State in the Spanning Layer](https://banes-lab.com/records/lexicon/retain-the-prior-state-in-the-spanning-layer.md): A technique for keeping the earlier state of content in the layer that spans both states, so a change rule can compare them.
- [Compare the Two Readings](https://banes-lab.com/records/lexicon/compare-the-two-readings.md): A technique for enforcing a change rule by comparing the content before and after the change.
- [Type the Carrier](https://banes-lab.com/records/lexicon/type-the-carrier.md): A technique for giving the fields a mechanism reads a resolvable typed form.
- [Leave the Payload Prose](https://banes-lab.com/records/lexicon/leave-the-payload-prose.md): A technique for keeping the fields only people read as prose that no mechanism parses.
- [Remove the Restating Payload](https://banes-lab.com/records/lexicon/remove-the-restating-payload.md): A technique for deleting payload text that restates what its carrier already answers.
- [Draw the Value from a Closed Set](https://banes-lab.com/records/lexicon/draw-the-value-from-a-closed-set.md): A technique for making a mandated field take a value from a declared closed set that a consumer can join on.
- [Declare the Field for Readers](https://banes-lab.com/records/lexicon/declare-the-field-for-readers.md): A technique for declaring that a mandated prose field is written for people, so no consumer is assumed to read it.
- [Write the Aggregate Only from a Full Run](https://banes-lab.com/records/lexicon/write-the-aggregate-only-from-a-full-run.md): A technique for overwriting an aggregate report only from a run that measured its whole population.
- [Stream Narrowed Verdicts](https://banes-lab.com/records/lexicon/stream-narrowed-verdicts.md): A technique for returning the verdicts of a narrowed run to its caller instead of writing them as a report.
- [Keep One Aggregate](https://banes-lab.com/records/lexicon/keep-one-aggregate.md): A technique for holding one aggregate report per subject, with no report named for a scope or caller beside it.
- [Treat the Statements as One Unit](https://banes-lab.com/records/lexicon/treat-the-statements-as-one-unit.md): A technique for treating every statement of one invariant as a single unit that one query ranges over.
- [Re-Derive Every Copy on Change](https://banes-lab.com/records/lexicon/re-derive-every-copy-on-change.md): A technique for regenerating every copy of an invariant from its source whenever the source changes.
- [Refuse and Name the Cycle](https://banes-lab.com/records/lexicon/refuse-and-name-the-cycle.md): A technique for refusing to collapse a set of copies with no distinguished member and reporting the cycle by name.
- [Archive the Absorbed Venue](https://banes-lab.com/records/lexicon/archive-the-absorbed-venue.md): A technique for moving a closed venue to the archive once its outcome is absorbed, instead of deleting it.
- [Is-A Test](https://banes-lab.com/records/lexicon/is-a-test.md): A technique for deciding concern membership by asking whether a file is-a the proposed word, admitting it as a role when it is and as a domain noun when the system merely has-a it.
- [Reverse Coverage Resolution](https://banes-lab.com/records/lexicon/reverse-coverage-resolution.md): A technique for answering which declared words cover a candidate, by indexing the rejection table on its refused words rather than on the concerns they map to.
- [Rename to a Declared Word](https://banes-lab.com/records/lexicon/rename-to-a-declared-word.md): A technique for replacing an undeclared word in a name with the declared word that covers its role.
- [Split the Compound](https://banes-lab.com/records/lexicon/split-the-compound.md): A technique for separating a word that fused a subject and a concern into its two slots.
- [Move the Tag to the Concern Slot](https://banes-lab.com/records/lexicon/move-the-tag-to-the-concern-slot.md): A technique for placing a concern tag as the last segment of a filename, where the parser reads the concern.
- [Correct the Resolver](https://banes-lab.com/records/lexicon/correct-the-resolver.md): A technique for fixing a slot resolver that reads a word by its vocabulary instead of by its position.
- [Move to the Matching Concern Folder](https://banes-lab.com/records/lexicon/move-to-the-matching-concern-folder.md): A technique for moving a file into the folder whose label equals its concern tag.
- [Reclassify the File](https://banes-lab.com/records/lexicon/reclassify-the-file.md): A technique for reading a file again and giving it the concern tag its code supports.
- [Unanchor the Pattern](https://banes-lab.com/records/lexicon/unanchor-the-pattern.md): A technique for writing a discovery pattern that matches a concern at any depth instead of at one.
- [Restore the Terminating Tag](https://banes-lab.com/records/lexicon/restore-the-terminating-tag.md): A technique for ending a filename with its concern tag again, so a glob on the tag finds it.
- [Declare the Root](https://banes-lab.com/records/lexicon/declare-the-root.md): A technique for adding a folder to the jurisdiction declaration instead of inferring that it is governed.
- [Place the Folder in an Existing Container](https://banes-lab.com/records/lexicon/place-the-folder-in-an-existing-container.md): A technique for moving a folder under the container that already groups its kind of content.
- [Remove the Ignore Entry](https://banes-lab.com/records/lexicon/remove-the-ignore-entry.md): A technique for deleting an ignore entry that hid authored source and fixing the finding it silenced.
- [Collapse the Exemption Lists](https://banes-lab.com/records/lexicon/collapse-the-exemption-lists.md): A technique for replacing per-check exemption lists for one upstream tree with a single declaration every check reads.
- [Take the Variant Slot](https://banes-lab.com/records/lexicon/take-the-variant-slot.md): A technique for resolving a name collision with a declared variant instead of a new folder level.
- [Add a Sibling Subject Folder](https://banes-lab.com/records/lexicon/add-a-sibling-subject-folder.md): A technique for relieving breadth with a subject folder beside the existing one instead of below it.
- [Split by Responsibility](https://banes-lab.com/records/lexicon/split-by-responsibility.md): A technique for dividing a file that holds two concerns into one file per concern.
- [Reclassify to the Narrower Role](https://banes-lab.com/records/lexicon/reclassify-to-the-narrower-role.md): A technique for moving a file from a broad concern tag to the narrowest tag that still fits it.
- [Apply the Domain-Ward Tie-Break](https://banes-lab.com/records/lexicon/apply-the-domain-ward-tie-break.md): A technique for resolving an irreducible two-concern overlap toward the concern nearer the domain on the layer spine.
- [Classify to the Meta Concern](https://banes-lab.com/records/lexicon/classify-to-the-meta-concern.md): A technique for tagging a file with the agnostic concern that covers its role instead of a domain word.
- [Index the Rejection Table by Refused Word](https://banes-lab.com/records/lexicon/index-the-rejection-table-by-refused-word.md): A technique for keying the table of rejected words by the refused word, so the gate can look up its replacement.
- [Name the Covering Concern in the Refusal](https://banes-lab.com/records/lexicon/name-the-covering-concern-in-the-refusal.md): A technique for having a vocabulary refusal name the declared word that covers the refused one.
- [Derive the Registry from the Document](https://banes-lab.com/records/lexicon/derive-the-registry-from-the-document.md): A technique for generating the machine-read vocabulary from the document that reasons about it, so the two cannot drift.
- [Move Reasoning Back to the Document](https://banes-lab.com/records/lexicon/move-reasoning-back-to-the-document.md): A technique for moving rules written into a declaration file back into the document that people read.
- [Drop the Redundant Head](https://banes-lab.com/records/lexicon/drop-the-redundant-head.md): A technique for removing from a filename the subject its folder already declares.
- [Re-Point the Pattern](https://banes-lab.com/records/lexicon/re-point-the-pattern.md): A technique for updating every shape-discovered surface whose pattern encoded a renamed form.
- [Verify the Collected Count](https://banes-lab.com/records/lexicon/verify-the-collected-count.md): A technique for comparing what each aggregator collects before and after a rename, treating a drop to zero as a failure.
- [Compare Both Files](https://banes-lab.com/records/lexicon/compare-both-files.md): A technique for comparing the responsibilities of two colliding files before giving either a variant.
- [Merge One Job or Name the Facet](https://banes-lab.com/records/lexicon/merge-one-job-or-name-the-facet.md): A technique for merging two files that do one job, or giving the variant the facet that truly differs.
- [Move the Test with Its Subject](https://banes-lab.com/records/lexicon/move-the-test-with-its-subject.md): A technique for moving a test to the mirrored path of its subject whenever the subject moves.
- [Split One Test per Subject](https://banes-lab.com/records/lexicon/split-one-test-per-subject.md): A technique for dividing a test that covers several subjects into one test file per subject.
- [Take the Domain Noun as the Subject](https://banes-lab.com/records/lexicon/take-the-domain-noun-as-the-subject.md): A technique for replacing the generic subject with the domain noun the file's source names.
- [Classify Before the First Write](https://banes-lab.com/records/lexicon/classify-before-the-first-write.md): A technique for deciding a file's concern and subject before writing it, so it is created under its final name.
- [Move the Order into the Registry](https://banes-lab.com/records/lexicon/move-the-order-into-the-registry.md): A technique for recording a sequence in a registry instead of in numeric filename prefixes.
- [Drop the Prefix](https://banes-lab.com/records/lexicon/drop-the-prefix.md): A technique for removing a numeric order prefix from filenames once a registry holds the order.
- [Resolve the Slot Against Its Source](https://banes-lab.com/records/lexicon/resolve-the-slot-against-its-source.md): A technique for checking a slot word against the source that allocates it instead of against a copied vocabulary.
- [Remove the Copies](https://banes-lab.com/records/lexicon/remove-the-copies.md): A technique for deleting vocabulary entries that copy words another source already owns.
- [Declare the Dialect](https://banes-lab.com/records/lexicon/declare-the-dialect.md): A technique for binding a file extension to the case splitter its language uses.
- [Rename to the Case's Word Run](https://banes-lab.com/records/lexicon/rename-to-the-case-s-word-run.md): A technique for renaming a dialect file so its case splitter yields the three declared slots.
- [Move the File into Its Concern Folder](https://banes-lab.com/records/lexicon/move-the-file-into-its-concern-folder.md): A technique for moving a loose root file into the concern folder its tag names.
- [Reconciliation Job](https://banes-lab.com/records/lexicon/reconciliation-job.md): A technique for periodically comparing two copies of related state and repairing the differences found.
- [Merge Policy](https://banes-lab.com/records/lexicon/merge-policy.md): A technique for declaring how two concurrent changes to one value are combined.
- [Transaction Isolation Level](https://banes-lab.com/records/lexicon/transaction-isolation-level.md): A technique for choosing how much concurrent transactions see of each other's uncommitted and recent writes.
- [Make Immutable](https://banes-lab.com/records/lexicon/make-immutable.md): A technique for replacing in-place mutation with new values, so state shared between readers cannot change under them.
- [Read From Primary After Write](https://banes-lab.com/records/lexicon/read-from-primary-after-write.md): A technique for routing a client's reads to the primary for a short time after it writes, so it sees its own write.
- [Consistency Contract](https://banes-lab.com/records/lexicon/consistency-contract.md): A technique for stating which reads may be stale, for how long, and how a client learns that its write is visible.
- [Fix the Race](https://banes-lab.com/records/lexicon/fix-the-race.md): A technique for removing a race by ordering, locking or making the shared state immutable, instead of retrying the test.
- [Apply Concurrency Control](https://banes-lab.com/records/lexicon/apply-concurrency-control.md): A technique for coordinating concurrent writers with locks, versions or ownership, so no write is lost.
- [Introduce Transaction Boundary](https://banes-lab.com/records/lexicon/introduce-transaction-boundary.md): A technique for declaring which writes commit or fail together.
- [DSLs](https://banes-lab.com/records/lexicon/dsls.md): Domain-specific languages, small notations tailored to express solutions within one problem domain.
- [Code Generation](https://banes-lab.com/records/lexicon/code-generation.md): Producing source code automatically from a higher-level model, schema, or specification.
- [Name the Concept](https://banes-lab.com/records/lexicon/name-the-concept.md): A technique for giving a recurring group of values or steps a name in the domain language and one home in the code.
- [Name Constant](https://banes-lab.com/records/lexicon/name-constant.md): A technique for replacing an unexplained literal with a named constant that states its meaning.
- [Replace Boolean with Enum](https://banes-lab.com/records/lexicon/replace-boolean-with-enum.md): A technique for replacing a boolean parameter or flag with a closed set of named values.